kjs
/
ERP-node
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feature/prisma-to-raw-query-phase1-complete #82

Merged
kjs merged 29 commits from feature/prisma-to-raw-query-phase1-complete into main 2025-10-01 15:07:17 +09:00
Conversation 0 Commits 29 Files Changed 66 +7542 -9006
66 changed files with 7542 additions and 9006 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -150,9 +150,6 @@ jspm_packages/
ehthumbs.db
Thumbs.db
# Prisma
prisma/migrations/
# Build outputs
dist/
build/
@ -273,8 +270,6 @@ out/
.settings/
bin/
/src/generated/prisma
# 업로드된 파일들 제외
backend-node/uploads/
uploads/

12
DOCKER.md
View File

@ -6,7 +6,7 @@
**기술 스택:**
- **백엔드**: Node.js + TypeScript + Prisma + PostgreSQL
- **백엔드**: Node.js + TypeScript + PostgreSQL (Raw Query)
- **프론트엔드**: Next.js + TypeScript + Tailwind CSS
- **컨테이너**: Docker + Docker Compose
@ -98,12 +98,12 @@ npm install / npm uninstall # 패키지 설치/제거
package-lock.json 변경 # 의존성 잠금 파일
```
**Prisma 관련:**
**데이터베이스 관련:**
```bash
backend-node/prisma/schema.prisma # DB 스키마 변경
npx prisma migrate # 마이그레이션 실행
npx prisma generate # 클라이언트 재생성
db/ilshin.pgsql # DB 스키마 파일 변경
db/00-create-roles.sh # DB 초기화 스크립트 변경
# SQL 마이그레이션은 직접 실행
```
**설정 파일:**
@ -207,7 +207,7 @@ ERP-node/
│ ├── backend-node/
│ │ ├── Dockerfile # 프로덕션용
│ │ └── Dockerfile.dev # 개발용
│ └── src/, prisma/, package.json...
│ └── src/, database/, package.json...
│
├── 📁 프론트엔드
│ ├── frontend/

407
PHASE3.11_DDL_AUDIT_LOGGER_MIGRATION.md Normal file
View File

@ -0,0 +1,407 @@
# 📋 Phase 3.11: DDLAuditLogger Raw Query 전환 계획
## 📋 개요
DDLAuditLogger는 **8개의 Prisma 호출**이 있으며, DDL 실행 감사 로그 관리를 담당하는 서비스입니다.
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | --------------------------------------------- |
| 파일 위치 | `backend-node/src/services/ddlAuditLogger.ts` |
| 파일 크기 | 350 라인 |
| Prisma 호출 | 0개 (전환 완료) |
| **현재 진행률** | **8/8 (100%)** ✅ **전환 완료** |
| 복잡도 | 중간 (통계 쿼리, $executeRaw) |
| 우선순위 | 🟡 중간 (Phase 3.11) |
| **상태** | ✅ **완료** |
### 🎯 전환 목표
- ⏳ **8개 모든 Prisma 호출을 `db.ts`의 `query()`, `queryOne()` 함수로 교체**
- ⏳ DDL 감사 로그 기능 정상 동작
- ⏳ 통계 쿼리 전환 (GROUP BY, COUNT, ORDER BY)
- ⏳ $executeRaw → query 전환
- ⏳ $queryRawUnsafe → query 전환
- ⏳ 동적 WHERE 조건 생성
- ⏳ TypeScript 컴파일 성공
- ⏳ **Prisma import 완전 제거**
---
## 🔍 Prisma 사용 현황 분석
### 주요 Prisma 호출 (8개)
#### 1. **logDDLStart()** - DDL 시작 로그 (INSERT)
```typescript
// Line 27
const logEntry = await prisma.$executeRaw`
INSERT INTO ddl_audit_logs (
execution_id, ddl_type, table_name, status,
executed_by, company_code, started_at, metadata
) VALUES (
${executionId}, ${ddlType}, ${tableName}, 'in_progress',
${executedBy}, ${companyCode}, NOW(), ${JSON.stringify(metadata)}::jsonb
)
`;
```
#### 2. **getAuditLogs()** - 감사 로그 목록 조회 (SELECT with filters)
```typescript
// Line 162
const logs = await prisma.$queryRawUnsafe(query, ...params);
```
- 동적 WHERE 조건 생성
- 페이징 (OFFSET, LIMIT)
- 정렬 (ORDER BY)
#### 3. **getAuditStats()** - 통계 조회 (복합 쿼리)
```typescript
// Line 199 - 총 통계
const totalStats = (await prisma.$queryRawUnsafe(
`SELECT
COUNT(*) as total_executions,
COUNT(CASE WHEN status = 'success' THEN 1 END) as successful,
COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed,
AVG(EXTRACT(EPOCH FROM (completed_at - started_at))) as avg_duration
FROM ddl_audit_logs
WHERE ${whereClause}`
)) as any[];
// Line 212 - DDL 타입별 통계
const ddlTypeStats = (await prisma.$queryRawUnsafe(
`SELECT ddl_type, COUNT(*) as count
FROM ddl_audit_logs
WHERE ${whereClause}
GROUP BY ddl_type
ORDER BY count DESC`
)) as any[];
// Line 224 - 사용자별 통계
const userStats = (await prisma.$queryRawUnsafe(
`SELECT executed_by, COUNT(*) as count
FROM ddl_audit_logs
WHERE ${whereClause}
GROUP BY executed_by
ORDER BY count DESC
LIMIT 10`
)) as any[];
// Line 237 - 최근 실패 로그
const recentFailures = (await prisma.$queryRawUnsafe(
`SELECT * FROM ddl_audit_logs
WHERE status = 'failed' AND ${whereClause}
ORDER BY started_at DESC
LIMIT 5`
)) as any[];
```
#### 4. **getExecutionHistory()** - 실행 이력 조회
```typescript
// Line 287
const history = await prisma.$queryRawUnsafe(
`SELECT * FROM ddl_audit_logs
WHERE table_name = $1 AND company_code = $2
ORDER BY started_at DESC
LIMIT $3`,
tableName,
companyCode,
limit
);
```
#### 5. **cleanupOldLogs()** - 오래된 로그 삭제
```typescript
// Line 320
const result = await prisma.$executeRaw`
DELETE FROM ddl_audit_logs
WHERE started_at < NOW() - INTERVAL '${retentionDays} days'
AND company_code = ${companyCode}
`;
```
---
## 💡 전환 전략
### 1단계: $executeRaw 전환 (2개)
- `logDDLStart()` - INSERT
- `cleanupOldLogs()` - DELETE
### 2단계: 단순 $queryRawUnsafe 전환 (1개)
- `getExecutionHistory()` - 파라미터 바인딩 있음
### 3단계: 복잡한 $queryRawUnsafe 전환 (1개)
- `getAuditLogs()` - 동적 WHERE 조건
### 4단계: 통계 쿼리 전환 (4개)
- `getAuditStats()` 내부의 4개 쿼리
- GROUP BY, CASE WHEN, AVG, EXTRACT
---
## 💻 전환 예시
### 예시 1: $executeRaw → query (INSERT)
**변경 전**:
```typescript
const logEntry = await prisma.$executeRaw`
INSERT INTO ddl_audit_logs (
execution_id, ddl_type, table_name, status,
executed_by, company_code, started_at, metadata
) VALUES (
${executionId}, ${ddlType}, ${tableName}, 'in_progress',
${executedBy}, ${companyCode}, NOW(), ${JSON.stringify(metadata)}::jsonb
)
`;
```
**변경 후**:
```typescript
await query(
`INSERT INTO ddl_audit_logs (
execution_id, ddl_type, table_name, status,
executed_by, company_code, started_at, metadata
) VALUES ($1, $2, $3, $4, $5, $6, NOW(), $7::jsonb)`,
[
executionId,
ddlType,
tableName,
"in_progress",
executedBy,
companyCode,
JSON.stringify(metadata),
]
);
```
### 예시 2: 동적 WHERE 조건
**변경 전**:
```typescript
let query = `SELECT * FROM ddl_audit_logs WHERE 1=1`;
const params: any[] = [];
if (filters.ddlType) {
query += ` AND ddl_type = ?`;
params.push(filters.ddlType);
}
const logs = await prisma.$queryRawUnsafe(query, ...params);
```
**변경 후**:
```typescript
const conditions: string[] = [];
const params: any[] = [];
let paramIndex = 1;
if (filters.ddlType) {
conditions.push(`ddl_type = $${paramIndex++}`);
params.push(filters.ddlType);
}
const whereClause =
conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
const sql = `SELECT * FROM ddl_audit_logs ${whereClause}`;
const logs = await query<any>(sql, params);
```
### 예시 3: 통계 쿼리 (GROUP BY)
**변경 전**:
```typescript
const ddlTypeStats = (await prisma.$queryRawUnsafe(
`SELECT ddl_type, COUNT(*) as count
FROM ddl_audit_logs
WHERE ${whereClause}
GROUP BY ddl_type
ORDER BY count DESC`
)) as any[];
```
**변경 후**:
```typescript
const ddlTypeStats = await query<{ ddl_type: string; count: string }>(
`SELECT ddl_type, COUNT(*) as count
FROM ddl_audit_logs
WHERE ${whereClause}
GROUP BY ddl_type
ORDER BY count DESC`,
params
);
```
---
## 🔧 기술적 고려사항
### 1. JSON 필드 처리
`metadata` 필드는 JSONB 타입으로, INSERT 시 `::jsonb` 캐스팅 필요:
```typescript
JSON.stringify(metadata) + "::jsonb";
```
### 2. 날짜/시간 함수
- `NOW()` - 현재 시간
- `INTERVAL '30 days'` - 날짜 간격
- `EXTRACT(EPOCH FROM ...)` - 초 단위 변환
### 3. CASE WHEN 집계
```sql
COUNT(CASE WHEN status = 'success' THEN 1 END) as successful
```
### 4. 동적 WHERE 조건
여러 필터를 조합하여 WHERE 절 생성:
- ddlType
- tableName
- status
- executedBy
- dateRange (startDate, endDate)
---
## ✅ 전환 완료 내역
### 전환된 Prisma 호출 (8개)
1. **`logDDLExecution()`** - DDL 실행 로그 INSERT
- Before: `prisma.$executeRaw`
- After: `query()` with 7 parameters
2. **`getAuditLogs()`** - 감사 로그 목록 조회
- Before: `prisma.$queryRawUnsafe`
- After: `query<any>()` with dynamic WHERE clause
3. **`getDDLStatistics()`** - 통계 조회 (4개 쿼리)
- Before: 4x `prisma.$queryRawUnsafe`
- After: 4x `query<any>()`
- totalStats: 전체 실행 통계 (CASE WHEN 집계)
- ddlTypeStats: DDL 타입별 통계 (GROUP BY)
- userStats: 사용자별 통계 (GROUP BY, LIMIT 10)
- recentFailures: 최근 실패 로그 (WHERE success = false)
4. **`getTableDDLHistory()`** - 테이블별 DDL 히스토리
- Before: `prisma.$queryRawUnsafe`
- After: `query<any>()` with table_name filter
5. **`cleanupOldLogs()`** - 오래된 로그 삭제
- Before: `prisma.$executeRaw`
- After: `query()` with date filter
### 주요 기술적 개선사항
1. **파라미터 바인딩**: PostgreSQL `$1, $2, ...` 스타일로 통일
2. **동적 WHERE 조건**: 파라미터 인덱스 자동 증가 로직 유지
3. **통계 쿼리**: CASE WHEN, GROUP BY, SUM 등 복잡한 집계 쿼리 완벽 전환
4. **에러 처리**: 기존 try-catch 구조 유지
5. **로깅**: logger 유틸리티 활용 유지
### 코드 정리
- [x] `import { PrismaClient }` 제거
- [x] `const prisma = new PrismaClient()` 제거
- [x] `import { query, queryOne }` 추가
- [x] 모든 타입 정의 유지
- [x] TypeScript 컴파일 성공
- [x] Linter 오류 없음
## 📝 원본 전환 체크리스트
### 1단계: Prisma 호출 전환 (✅ 완료)
- [ ] `logDDLStart()` - INSERT ($executeRaw → query)
- [ ] `logDDLComplete()` - UPDATE (이미 query 사용 중일 가능성)
- [ ] `logDDLError()` - UPDATE (이미 query 사용 중일 가능성)
- [ ] `getAuditLogs()` - SELECT with filters ($queryRawUnsafe → query)
- [ ] `getAuditStats()` 내 4개 쿼리:
- [ ] totalStats (집계 쿼리)
- [ ] ddlTypeStats (GROUP BY)
- [ ] userStats (GROUP BY + LIMIT)
- [ ] recentFailures (필터 + ORDER BY + LIMIT)
- [ ] `getExecutionHistory()` - SELECT with params ($queryRawUnsafe → query)
- [ ] `cleanupOldLogs()` - DELETE ($executeRaw → query)
### 2단계: 코드 정리
- [ ] import 문 수정 (`prisma` → `query, queryOne`)
- [ ] Prisma import 완전 제거
- [ ] 타입 정의 확인
### 3단계: 테스트
- [ ] 단위 테스트 작성 (8개)
- [ ] DDL 시작 로그 테스트
- [ ] DDL 완료 로그 테스트
- [ ] 감사 로그 목록 조회 테스트
- [ ] 통계 조회 테스트
- [ ] 실행 이력 조회 테스트
- [ ] 오래된 로그 삭제 테스트
- [ ] 통합 테스트 작성 (3개)
- [ ] 전체 DDL 실행 플로우 테스트
- [ ] 필터링 및 페이징 테스트
- [ ] 통계 정확성 테스트
- [ ] 성능 테스트
- [ ] 대량 로그 조회 성능
- [ ] 통계 쿼리 성능
### 4단계: 문서화
- [ ] 전환 완료 문서 업데이트
- [ ] 주요 변경사항 기록
- [ ] 성능 벤치마크 결과
---
## 🎯 예상 난이도 및 소요 시간
- **난이도**: ⭐⭐⭐ (중간)
- 복잡한 통계 쿼리 (GROUP BY, CASE WHEN)
- 동적 WHERE 조건 생성
- JSON 필드 처리
- **예상 소요 시간**: 1~1.5시간
- Prisma 호출 전환: 30분
- 테스트: 20분
- 문서화: 10분
---
## 📌 참고사항
### 관련 서비스
- `DDLExecutionService` - DDL 실행 (이미 전환 완료)
- `DDLSafetyValidator` - DDL 안전성 검증
### 의존성
- `../database/db` - query, queryOne 함수
- `../types/ddl` - DDL 관련 타입
- `../utils/logger` - 로깅
---
**상태**: ⏳ **대기 중**
**특이사항**: 통계 쿼리, JSON 필드, 동적 WHERE 조건 포함

356
PHASE3.12_EXTERNAL_CALL_CONFIG_SERVICE_MIGRATION.md Normal file
View File

@ -0,0 +1,356 @@
# 📋 Phase 3.12: ExternalCallConfigService Raw Query 전환 계획
## 📋 개요
ExternalCallConfigService는 **8개의 Prisma 호출**이 있으며, 외부 API 호출 설정 관리를 담당하는 서비스입니다.
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | -------------------------------------------------------- |
| 파일 위치 | `backend-node/src/services/externalCallConfigService.ts` |
| 파일 크기 | 612 라인 |
| Prisma 호출 | 0개 (전환 완료) |
| **현재 진행률** | **8/8 (100%)** ✅ **전환 완료** |
| 복잡도 | 중간 (JSON 필드, 복잡한 CRUD) |
| 우선순위 | 🟡 중간 (Phase 3.12) |
| **상태** | ✅ **완료** |
### 🎯 전환 목표
- ⏳ **8개 모든 Prisma 호출을 `db.ts`의 `query()`, `queryOne()` 함수로 교체**
- ⏳ 외부 호출 설정 CRUD 기능 정상 동작
- ⏳ JSON 필드 처리 (headers, params, auth_config)
- ⏳ 동적 WHERE 조건 생성
- ⏳ 민감 정보 암호화/복호화 유지
- ⏳ TypeScript 컴파일 성공
- ⏳ **Prisma import 완전 제거**
---
## 🔍 예상 Prisma 사용 패턴
### 주요 기능 (8개 예상)
#### 1. **외부 호출 설정 목록 조회**
- findMany with filters
- 페이징, 정렬
- 동적 WHERE 조건 (is_active, company_code, search)
#### 2. **외부 호출 설정 단건 조회**
- findUnique or findFirst
- config_id 기준
#### 3. **외부 호출 설정 생성**
- create
- JSON 필드 처리 (headers, params, auth_config)
- 민감 정보 암호화
#### 4. **외부 호출 설정 수정**
- update
- 동적 UPDATE 쿼리
- JSON 필드 업데이트
#### 5. **외부 호출 설정 삭제**
- delete or soft delete
#### 6. **외부 호출 설정 복제**
- findUnique + create
#### 7. **외부 호출 설정 테스트**
- findUnique
- 실제 HTTP 호출
#### 8. **외부 호출 이력 조회**
- findMany with 관계 조인
- 통계 쿼리
---
## 💡 전환 전략
### 1단계: 기본 CRUD 전환 (5개)
- getExternalCallConfigs() - 목록 조회
- getExternalCallConfig() - 단건 조회
- createExternalCallConfig() - 생성
- updateExternalCallConfig() - 수정
- deleteExternalCallConfig() - 삭제
### 2단계: 추가 기능 전환 (3개)
- duplicateExternalCallConfig() - 복제
- testExternalCallConfig() - 테스트
- getExternalCallHistory() - 이력 조회
---
## 💻 전환 예시
### 예시 1: 목록 조회 (동적 WHERE + JSON)
**변경 전**:
```typescript
const configs = await prisma.external_call_configs.findMany({
where: {
company_code: companyCode,
is_active: isActive,
OR: [
{ config_name: { contains: search, mode: "insensitive" } },
{ endpoint_url: { contains: search, mode: "insensitive" } },
],
},
orderBy: { created_at: "desc" },
skip,
take: limit,
});
```
**변경 후**:
```typescript
const conditions: string[] = ["company_code = $1"];
const params: any[] = [companyCode];
let paramIndex = 2;
if (isActive !== undefined) {
conditions.push(`is_active = $${paramIndex++}`);
params.push(isActive);
}
if (search) {
conditions.push(
`(config_name ILIKE $${paramIndex} OR endpoint_url ILIKE $${paramIndex})`
);
params.push(`%${search}%`);
paramIndex++;
}
const configs = await query<any>(
`SELECT * FROM external_call_configs
WHERE ${conditions.join(" AND ")}
ORDER BY created_at DESC
LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
[...params, limit, skip]
);
```
### 예시 2: JSON 필드 생성
**변경 전**:
```typescript
const config = await prisma.external_call_configs.create({
data: {
config_name: data.config_name,
endpoint_url: data.endpoint_url,
http_method: data.http_method,
headers: data.headers, // JSON
params: data.params, // JSON
auth_config: encryptedAuthConfig, // JSON (암호화됨)
company_code: companyCode,
},
});
```
**변경 후**:
```typescript
const config = await queryOne<any>(
`INSERT INTO external_call_configs
(config_name, endpoint_url, http_method, headers, params,
auth_config, company_code, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, NOW(), NOW())
RETURNING *`,
[
data.config_name,
data.endpoint_url,
data.http_method,
JSON.stringify(data.headers),
JSON.stringify(data.params),
JSON.stringify(encryptedAuthConfig),
companyCode,
]
);
```
### 예시 3: 동적 UPDATE (JSON 포함)
**변경 전**:
```typescript
const updateData: any = {};
if (data.headers) updateData.headers = data.headers;
if (data.params) updateData.params = data.params;
const config = await prisma.external_call_configs.update({
where: { config_id: configId },
data: updateData,
});
```
**변경 후**:
```typescript
const updateFields: string[] = ["updated_at = NOW()"];
const values: any[] = [];
let paramIndex = 1;
if (data.headers !== undefined) {
updateFields.push(`headers = $${paramIndex++}`);
values.push(JSON.stringify(data.headers));
}
if (data.params !== undefined) {
updateFields.push(`params = $${paramIndex++}`);
values.push(JSON.stringify(data.params));
}
const config = await queryOne<any>(
`UPDATE external_call_configs
SET ${updateFields.join(", ")}
WHERE config_id = $${paramIndex}
RETURNING *`,
[...values, configId]
);
```
---
## 🔧 기술적 고려사항
### 1. JSON 필드 처리
3개의 JSON 필드가 있을 것으로 예상:
- `headers` - HTTP 헤더
- `params` - 쿼리 파라미터
- `auth_config` - 인증 설정 (암호화됨)
```typescript
// INSERT/UPDATE 시
JSON.stringify(jsonData);
// SELECT 후
const parsedData =
typeof row.headers === "string" ? JSON.parse(row.headers) : row.headers;
```
### 2. 민감 정보 암호화
auth_config는 암호화되어 저장되므로, 기존 암호화/복호화 로직 유지:
```typescript
import { encrypt, decrypt } from "../utils/encryption";
// 저장 시
const encryptedAuthConfig = encrypt(JSON.stringify(authConfig));
// 조회 시
const decryptedAuthConfig = JSON.parse(decrypt(row.auth_config));
```
### 3. HTTP 메소드 검증
```typescript
const VALID_HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
if (!VALID_HTTP_METHODS.includes(httpMethod)) {
throw new Error("Invalid HTTP method");
}
```
### 4. URL 검증
```typescript
try {
new URL(endpointUrl);
} catch {
throw new Error("Invalid endpoint URL");
}
```
---
## ✅ 전환 완료 내역
### 전환된 Prisma 호출 (8개)
1. **`getConfigs()`** - 목록 조회 (findMany → query)
2. **`getConfigById()`** - 단건 조회 (findUnique → queryOne)
3. **`createConfig()`** - 중복 검사 (findFirst → queryOne)
4. **`createConfig()`** - 생성 (create → queryOne with INSERT)
5. **`updateConfig()`** - 중복 검사 (findFirst → queryOne)
6. **`updateConfig()`** - 수정 (update → queryOne with 동적 UPDATE)
7. **`deleteConfig()`** - 삭제 (update → query)
8. **`getExternalCallConfigsForButtonControl()`** - 조회 (findMany → query)
### 주요 기술적 개선사항
- 동적 WHERE 조건 생성 (company_code, call_type, api_type, is_active, search)
- ILIKE를 활용한 대소문자 구분 없는 검색
- 동적 UPDATE 쿼리 (9개 필드)
- JSON 필드 처리 (`config_data` → `JSON.stringify()`)
- 중복 검사 로직 유지
### 코드 정리
- [x] import 문 수정 완료
- [x] Prisma import 완전 제거
- [x] TypeScript 컴파일 성공
- [x] Linter 오류 없음
## 📝 원본 전환 체크리스트
### 1단계: Prisma 호출 전환 (✅ 완료)
- [ ] `getExternalCallConfigs()` - 목록 조회 (findMany + count)
- [ ] `getExternalCallConfig()` - 단건 조회 (findUnique)
- [ ] `createExternalCallConfig()` - 생성 (create)
- [ ] `updateExternalCallConfig()` - 수정 (update)
- [ ] `deleteExternalCallConfig()` - 삭제 (delete)
- [ ] `duplicateExternalCallConfig()` - 복제 (findUnique + create)
- [ ] `testExternalCallConfig()` - 테스트 (findUnique)
- [ ] `getExternalCallHistory()` - 이력 조회 (findMany)
### 2단계: 코드 정리
- [ ] import 문 수정 (`prisma` → `query, queryOne`)
- [ ] JSON 필드 처리 확인
- [ ] 암호화/복호화 로직 유지
- [ ] Prisma import 완전 제거
### 3단계: 테스트
- [ ] 단위 테스트 작성 (8개)
- [ ] 통합 테스트 작성 (3개)
- [ ] 암호화 테스트
- [ ] HTTP 호출 테스트
### 4단계: 문서화
- [ ] 전환 완료 문서 업데이트
- [ ] API 문서 업데이트
---
## 🎯 예상 난이도 및 소요 시간
- **난이도**: ⭐⭐⭐ (중간)
- JSON 필드 처리
- 암호화/복호화 로직
- HTTP 호출 테스트
- **예상 소요 시간**: 1~1.5시간
---
**상태**: ⏳ **대기 중**
**특이사항**: JSON 필드, 민감 정보 암호화, HTTP 호출 포함

338
PHASE3.13_ENTITY_JOIN_SERVICE_MIGRATION.md Normal file
View File

@ -0,0 +1,338 @@
# 📋 Phase 3.13: EntityJoinService Raw Query 전환 계획
## 📋 개요
EntityJoinService는 **5개의 Prisma 호출**이 있으며, 엔티티 간 조인 관계 관리를 담당하는 서비스입니다.
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | ------------------------------------------------ |
| 파일 위치 | `backend-node/src/services/entityJoinService.ts` |
| 파일 크기 | 575 라인 |
| Prisma 호출 | 0개 (전환 완료) |
| **현재 진행률** | **5/5 (100%)** ✅ **전환 완료** |
| 복잡도 | 중간 (조인 쿼리, 관계 설정) |
| 우선순위 | 🟡 중간 (Phase 3.13) |
| **상태** | ✅ **완료** |
### 🎯 전환 목표
- ⏳ **5개 모든 Prisma 호출을 `db.ts`의 `query()`, `queryOne()` 함수로 교체**
- ⏳ 엔티티 조인 설정 CRUD 기능 정상 동작
- ⏳ 복잡한 조인 쿼리 전환 (LEFT JOIN, INNER JOIN)
- ⏳ 조인 유효성 검증
- ⏳ TypeScript 컴파일 성공
- ⏳ **Prisma import 완전 제거**
---
## 🔍 예상 Prisma 사용 패턴
### 주요 기능 (5개 예상)
#### 1. **엔티티 조인 목록 조회**
- findMany with filters
- 동적 WHERE 조건
- 페이징, 정렬
#### 2. **엔티티 조인 단건 조회**
- findUnique or findFirst
- join_id 기준
#### 3. **엔티티 조인 생성**
- create
- 조인 유효성 검증
#### 4. **엔티티 조인 수정**
- update
- 동적 UPDATE 쿼리
#### 5. **엔티티 조인 삭제**
- delete
---
## 💡 전환 전략
### 1단계: 기본 CRUD 전환 (5개)
- getEntityJoins() - 목록 조회
- getEntityJoin() - 단건 조회
- createEntityJoin() - 생성
- updateEntityJoin() - 수정
- deleteEntityJoin() - 삭제
---
## 💻 전환 예시
### 예시 1: 조인 설정 조회 (LEFT JOIN으로 테이블 정보 포함)
**변경 전**:
```typescript
const joins = await prisma.entity_joins.findMany({
where: {
company_code: companyCode,
is_active: true,
},
include: {
source_table: true,
target_table: true,
},
orderBy: { created_at: "desc" },
});
```
**변경 후**:
```typescript
const joins = await query<any>(
`SELECT
ej.*,
st.table_name as source_table_name,
st.table_label as source_table_label,
tt.table_name as target_table_name,
tt.table_label as target_table_label
FROM entity_joins ej
LEFT JOIN tables st ON ej.source_table_id = st.table_id
LEFT JOIN tables tt ON ej.target_table_id = tt.table_id
WHERE ej.company_code = $1 AND ej.is_active = $2
ORDER BY ej.created_at DESC`,
[companyCode, true]
);
```
### 예시 2: 조인 생성 (유효성 검증 포함)
**변경 전**:
```typescript
// 조인 유효성 검증
const sourceTable = await prisma.tables.findUnique({
where: { table_id: sourceTableId },
});
const targetTable = await prisma.tables.findUnique({
where: { table_id: targetTableId },
});
if (!sourceTable || !targetTable) {
throw new Error("Invalid table references");
}
// 조인 생성
const join = await prisma.entity_joins.create({
data: {
source_table_id: sourceTableId,
target_table_id: targetTableId,
join_type: joinType,
join_condition: joinCondition,
company_code: companyCode,
},
});
```
**변경 후**:
```typescript
// 조인 유효성 검증 (Promise.all로 병렬 실행)
const [sourceTable, targetTable] = await Promise.all([
queryOne<any>(`SELECT * FROM tables WHERE table_id = $1`, [sourceTableId]),
queryOne<any>(`SELECT * FROM tables WHERE table_id = $1`, [targetTableId]),
]);
if (!sourceTable || !targetTable) {
throw new Error("Invalid table references");
}
// 조인 생성
const join = await queryOne<any>(
`INSERT INTO entity_joins
(source_table_id, target_table_id, join_type, join_condition,
company_code, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, NOW(), NOW())
RETURNING *`,
[sourceTableId, targetTableId, joinType, joinCondition, companyCode]
);
```
### 예시 3: 조인 수정
**변경 전**:
```typescript
const join = await prisma.entity_joins.update({
where: { join_id: joinId },
data: {
join_type: joinType,
join_condition: joinCondition,
is_active: isActive,
},
});
```
**변경 후**:
```typescript
const updateFields: string[] = ["updated_at = NOW()"];
const values: any[] = [];
let paramIndex = 1;
if (joinType !== undefined) {
updateFields.push(`join_type = $${paramIndex++}`);
values.push(joinType);
}
if (joinCondition !== undefined) {
updateFields.push(`join_condition = $${paramIndex++}`);
values.push(joinCondition);
}
if (isActive !== undefined) {
updateFields.push(`is_active = $${paramIndex++}`);
values.push(isActive);
}
const join = await queryOne<any>(
`UPDATE entity_joins
SET ${updateFields.join(", ")}
WHERE join_id = $${paramIndex}
RETURNING *`,
[...values, joinId]
);
```
---
## 🔧 기술적 고려사항
### 1. 조인 타입 검증
```typescript
const VALID_JOIN_TYPES = ["INNER", "LEFT", "RIGHT", "FULL"];
if (!VALID_JOIN_TYPES.includes(joinType)) {
throw new Error("Invalid join type");
}
```
### 2. 조인 조건 검증
```typescript
// 조인 조건은 SQL 조건식 형태 (예: "source.id = target.parent_id")
// SQL 인젝션 방지를 위한 검증 필요
const isValidJoinCondition = /^[\w\s.=<>]+$/.test(joinCondition);
if (!isValidJoinCondition) {
throw new Error("Invalid join condition");
}
```
### 3. 순환 참조 방지
```typescript
// 조인이 순환 참조를 만들지 않는지 검증
async function checkCircularReference(
sourceTableId: number,
targetTableId: number
): Promise<boolean> {
// 재귀적으로 조인 관계 확인
// ...
}
```
### 4. LEFT JOIN으로 관련 테이블 정보 조회
조인 설정 조회 시 source/target 테이블 정보를 함께 가져오기 위해 LEFT JOIN 사용
---
## ✅ 전환 완료 내역
### 전환된 Prisma 호출 (5개)
1. **`detectEntityJoins()`** - 엔티티 컬럼 감지 (findMany → query)
- column_labels 조회
- web_type = 'entity' 필터
- reference_table/reference_column IS NOT NULL
2. **`validateJoinConfig()`** - 테이블 존재 확인 ($queryRaw → query)
- information_schema.tables 조회
- 참조 테이블 검증
3. **`validateJoinConfig()`** - 컬럼 존재 확인 ($queryRaw → query)
- information_schema.columns 조회
- 표시 컬럼 검증
4. **`getReferenceTableColumns()`** - 컬럼 정보 조회 ($queryRaw → query)
- information_schema.columns 조회
- 문자열 타입 컬럼만 필터
5. **`getReferenceTableColumns()`** - 라벨 정보 조회 (findMany → query)
- column_labels 조회
- 컬럼명과 라벨 매핑
### 주요 기술적 개선사항
- **information_schema 쿼리**: 파라미터 바인딩으로 변경 ($1, $2)
- **타입 안전성**: 명확한 반환 타입 지정
- **IS NOT NULL 조건**: Prisma의 { not: null } → IS NOT NULL
- **IN 조건**: 여러 데이터 타입 필터링
### 코드 정리
- [x] PrismaClient import 제거
- [x] import 문 수정 완료
- [x] TypeScript 컴파일 성공
- [x] Linter 오류 없음
## 📝 원본 전환 체크리스트
### 1단계: Prisma 호출 전환 (✅ 완료)
- [ ] `getEntityJoins()` - 목록 조회 (findMany with include)
- [ ] `getEntityJoin()` - 단건 조회 (findUnique)
- [ ] `createEntityJoin()` - 생성 (create with validation)
- [ ] `updateEntityJoin()` - 수정 (update)
- [ ] `deleteEntityJoin()` - 삭제 (delete)
### 2단계: 코드 정리
- [ ] import 문 수정 (`prisma` → `query, queryOne`)
- [ ] 조인 유효성 검증 로직 유지
- [ ] Prisma import 완전 제거
### 3단계: 테스트
- [ ] 단위 테스트 작성 (5개)
- [ ] 조인 유효성 검증 테스트
- [ ] 순환 참조 방지 테스트
- [ ] 통합 테스트 작성 (2개)
### 4단계: 문서화
- [ ] 전환 완료 문서 업데이트
---
## 🎯 예상 난이도 및 소요 시간
- **난이도**: ⭐⭐⭐ (중간)
- LEFT JOIN 쿼리
- 조인 유효성 검증
- 순환 참조 방지
- **예상 소요 시간**: 1시간
---
**상태**: ⏳ **대기 중**
**특이사항**: LEFT JOIN, 조인 유효성 검증, 순환 참조 방지 포함

456
PHASE3.14_AUTH_SERVICE_MIGRATION.md Normal file
View File

@ -0,0 +1,456 @@
# 📋 Phase 3.14: AuthService Raw Query 전환 계획
## 📋 개요
AuthService는 **5개의 Prisma 호출**이 있으며, 사용자 인증 및 권한 관리를 담당하는 서비스입니다.
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | ------------------------------------------ |
| 파일 위치 | `backend-node/src/services/authService.ts` |
| 파일 크기 | 335 라인 |
| Prisma 호출 | 0개 (이미 Phase 1.5에서 전환 완료) |
| **현재 진행률** | **5/5 (100%)** ✅ **전환 완료** |
| 복잡도 | 높음 (보안, 암호화, 세션 관리) |
| 우선순위 | 🟡 중간 (Phase 3.14) |
| **상태** | ✅ **완료** (Phase 1.5에서 이미 완료) |
### 🎯 전환 목표
- ⏳ **5개 모든 Prisma 호출을 `db.ts`의 `query()`, `queryOne()` 함수로 교체**
- ⏳ 사용자 인증 기능 정상 동작
- ⏳ 비밀번호 암호화/검증 유지
- ⏳ 세션 관리 기능 유지
- ⏳ 권한 검증 기능 유지
- ⏳ TypeScript 컴파일 성공
- ⏳ **Prisma import 완전 제거**
---
## 🔍 예상 Prisma 사용 패턴
### 주요 기능 (5개 예상)
#### 1. **사용자 로그인 (인증)**
- findFirst or findUnique
- 이메일/사용자명으로 조회
- 비밀번호 검증
#### 2. **사용자 정보 조회**
- findUnique
- user_id 기준
- 권한 정보 포함
#### 3. **사용자 생성 (회원가입)**
- create
- 비밀번호 암호화
- 중복 검사
#### 4. **비밀번호 변경**
- update
- 기존 비밀번호 검증
- 새 비밀번호 암호화
#### 5. **세션 관리**
- create, update, delete
- 세션 토큰 저장/조회
---
## 💡 전환 전략
### 1단계: 인증 관련 전환 (2개)
- login() - 사용자 조회 + 비밀번호 검증
- getUserInfo() - 사용자 정보 조회
### 2단계: 사용자 관리 전환 (2개)
- createUser() - 사용자 생성
- changePassword() - 비밀번호 변경
### 3단계: 세션 관리 전환 (1개)
- manageSession() - 세션 CRUD
---
## 💻 전환 예시
### 예시 1: 로그인 (비밀번호 검증)
**변경 전**:
```typescript
async login(username: string, password: string) {
const user = await prisma.users.findFirst({
where: {
OR: [
{ username: username },
{ email: username },
],
is_active: true,
},
});
if (!user) {
throw new Error("User not found");
}
const isPasswordValid = await bcrypt.compare(password, user.password_hash);
if (!isPasswordValid) {
throw new Error("Invalid password");
}
return user;
}
```
**변경 후**:
```typescript
async login(username: string, password: string) {
const user = await queryOne<any>(
`SELECT * FROM users
WHERE (username = $1 OR email = $1)
AND is_active = $2`,
[username, true]
);
if (!user) {
throw new Error("User not found");
}
const isPasswordValid = await bcrypt.compare(password, user.password_hash);
if (!isPasswordValid) {
throw new Error("Invalid password");
}
return user;
}
```
### 예시 2: 사용자 생성 (비밀번호 암호화)
**변경 전**:
```typescript
async createUser(userData: CreateUserDto) {
// 중복 검사
const existing = await prisma.users.findFirst({
where: {
OR: [
{ username: userData.username },
{ email: userData.email },
],
},
});
if (existing) {
throw new Error("User already exists");
}
// 비밀번호 암호화
const passwordHash = await bcrypt.hash(userData.password, 10);
// 사용자 생성
const user = await prisma.users.create({
data: {
username: userData.username,
email: userData.email,
password_hash: passwordHash,
company_code: userData.company_code,
},
});
return user;
}
```
**변경 후**:
```typescript
async createUser(userData: CreateUserDto) {
// 중복 검사
const existing = await queryOne<any>(
`SELECT * FROM users
WHERE username = $1 OR email = $2`,
[userData.username, userData.email]
);
if (existing) {
throw new Error("User already exists");
}
// 비밀번호 암호화
const passwordHash = await bcrypt.hash(userData.password, 10);
// 사용자 생성
const user = await queryOne<any>(
`INSERT INTO users
(username, email, password_hash, company_code, created_at, updated_at)
VALUES ($1, $2, $3, $4, NOW(), NOW())
RETURNING *`,
[userData.username, userData.email, passwordHash, userData.company_code]
);
return user;
}
```
### 예시 3: 비밀번호 변경
**변경 전**:
```typescript
async changePassword(
userId: number,
oldPassword: string,
newPassword: string
) {
const user = await prisma.users.findUnique({
where: { user_id: userId },
});
if (!user) {
throw new Error("User not found");
}
const isOldPasswordValid = await bcrypt.compare(
oldPassword,
user.password_hash
);
if (!isOldPasswordValid) {
throw new Error("Invalid old password");
}
const newPasswordHash = await bcrypt.hash(newPassword, 10);
await prisma.users.update({
where: { user_id: userId },
data: { password_hash: newPasswordHash },
});
}
```
**변경 후**:
```typescript
async changePassword(
userId: number,
oldPassword: string,
newPassword: string
) {
const user = await queryOne<any>(
`SELECT * FROM users WHERE user_id = $1`,
[userId]
);
if (!user) {
throw new Error("User not found");
}
const isOldPasswordValid = await bcrypt.compare(
oldPassword,
user.password_hash
);
if (!isOldPasswordValid) {
throw new Error("Invalid old password");
}
const newPasswordHash = await bcrypt.hash(newPassword, 10);
await query(
`UPDATE users
SET password_hash = $1, updated_at = NOW()
WHERE user_id = $2`,
[newPasswordHash, userId]
);
}
```
---
## 🔧 기술적 고려사항
### 1. 비밀번호 보안
```typescript
import bcrypt from "bcrypt";
// 비밀번호 해싱 (회원가입, 비밀번호 변경)
const SALT_ROUNDS = 10;
const passwordHash = await bcrypt.hash(password, SALT_ROUNDS);
// 비밀번호 검증 (로그인)
const isValid = await bcrypt.compare(plainPassword, passwordHash);
```
### 2. SQL 인젝션 방지
```typescript
// ❌ 위험: 직접 문자열 결합
const sql = `SELECT * FROM users WHERE username = '${username}'`;
// ✅ 안전: 파라미터 바인딩
const user = await queryOne(`SELECT * FROM users WHERE username = $1`, [
username,
]);
```
### 3. 세션 토큰 관리
```typescript
import crypto from "crypto";
// 세션 토큰 생성
const sessionToken = crypto.randomBytes(32).toString("hex");
// 세션 저장
await query(
`INSERT INTO user_sessions (user_id, session_token, expires_at)
VALUES ($1, $2, NOW() + INTERVAL '1 day')`,
[userId, sessionToken]
);
```
### 4. 권한 검증
```typescript
async checkPermission(userId: number, permission: string): Promise<boolean> {
const result = await queryOne<{ has_permission: boolean }>(
`SELECT EXISTS (
SELECT 1 FROM user_permissions up
JOIN permissions p ON up.permission_id = p.permission_id
WHERE up.user_id = $1 AND p.permission_name = $2
) as has_permission`,
[userId, permission]
);
return result?.has_permission || false;
}
```
---
## ✅ 전환 완료 내역 (Phase 1.5에서 이미 완료됨)
AuthService는 Phase 1.5에서 이미 Raw Query로 전환이 완료되었습니다.
### 전환된 Prisma 호출 (5개)
1. **`loginPwdCheck()`** - 로그인 비밀번호 검증
- user_info 테이블에서 비밀번호 조회
- EncryptUtil을 활용한 비밀번호 검증
- 마스터 패스워드 지원
2. **`insertLoginAccessLog()`** - 로그인 로그 기록
- login_access_log 테이블에 INSERT
- 로그인 시간, IP 주소 등 기록
3. **`getUserInfo()`** - 사용자 정보 조회
- user_info 테이블 조회
- PersonBean 객체로 반환
4. **`updateLastLoginDate()`** - 마지막 로그인 시간 업데이트
- user_info 테이블 UPDATE
- last_login_date 갱신
5. **`checkUserPermission()`** - 사용자 권한 확인
- user_auth 테이블 조회
- 권한 코드 검증
### 주요 기술적 특징
- **보안**: EncryptUtil을 활용한 안전한 비밀번호 검증
- **JWT 토큰**: JwtUtils를 활용한 토큰 생성 및 검증
- **로깅**: 상세한 로그인 이력 기록
- **에러 처리**: 안전한 에러 메시지 반환
### 코드 상태
- [x] Prisma import 없음
- [x] query 함수 사용 중
- [x] TypeScript 컴파일 성공
- [x] 보안 로직 유지
## 📝 원본 전환 체크리스트
### 1단계: Prisma 호출 전환 (✅ Phase 1.5에서 완료)
- [ ] `login()` - 사용자 조회 + 비밀번호 검증 (findFirst)
- [ ] `getUserInfo()` - 사용자 정보 조회 (findUnique)
- [ ] `createUser()` - 사용자 생성 (create with 중복 검사)
- [ ] `changePassword()` - 비밀번호 변경 (findUnique + update)
- [ ] `manageSession()` - 세션 관리 (create/update/delete)
### 2단계: 보안 검증
- [ ] 비밀번호 해싱 로직 유지 (bcrypt)
- [ ] SQL 인젝션 방지 확인
- [ ] 세션 토큰 보안 확인
- [ ] 중복 계정 방지 확인
### 3단계: 테스트
- [ ] 단위 테스트 작성 (5개)
- [ ] 로그인 성공/실패 테스트
- [ ] 사용자 생성 테스트
- [ ] 비밀번호 변경 테스트
- [ ] 세션 관리 테스트
- [ ] 권한 검증 테스트
- [ ] 보안 테스트
- [ ] SQL 인젝션 테스트
- [ ] 비밀번호 강도 테스트
- [ ] 세션 탈취 방지 테스트
- [ ] 통합 테스트 작성 (2개)
### 4단계: 문서화
- [ ] 전환 완료 문서 업데이트
- [ ] 보안 가이드 업데이트
---
## 🎯 예상 난이도 및 소요 시간
- **난이도**: ⭐⭐⭐⭐ (높음)
- 보안 크리티컬 (비밀번호, 세션)
- SQL 인젝션 방지 필수
- 철저한 테스트 필요
- **예상 소요 시간**: 1.5~2시간
- Prisma 호출 전환: 40분
- 보안 검증: 40분
- 테스트: 40분
---
## ⚠️ 주의사항
### 보안 필수 체크리스트
1. ✅ 모든 사용자 입력은 파라미터 바인딩 사용
2. ✅ 비밀번호는 절대 평문 저장 금지 (bcrypt 사용)
3. ✅ 세션 토큰은 충분히 길고 랜덤해야 함
4. ✅ 비밀번호 실패 시 구체적 오류 메시지 금지 ("User not found" vs "Invalid credentials")
5. ✅ 로그인 실패 횟수 제한 (Brute Force 방지)
---
**상태**: ⏳ **대기 중**
**특이사항**: 보안 크리티컬, 비밀번호 암호화, 세션 관리 포함
**⚠️ 주의**: 이 서비스는 보안에 매우 중요하므로 신중한 테스트 필수!

515
PHASE3.15_BATCH_SERVICES_MIGRATION.md Normal file
View File

@ -0,0 +1,515 @@
# 📋 Phase 3.15: Batch Services Raw Query 전환 계획
## 📋 개요
배치 관련 서비스들은 총 **24개의 Prisma 호출**이 있으며, 배치 작업 실행 및 관리를 담당합니다.
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | ---------------------------------------------------------- |
| 대상 서비스 | 4개 (BatchExternalDb, ExecutionLog, Management, Scheduler) |
| 파일 위치 | `backend-node/src/services/batch*.ts` |
| 총 파일 크기 | 2,161 라인 |
| Prisma 호출 | 0개 (전환 완료) |
| **현재 진행률** | **24/24 (100%)** ✅ **전환 완료** |
| 복잡도 | 높음 (외부 DB 연동, 스케줄링, 트랜잭션) |
| 우선순위 | 🔴 높음 (Phase 3.15) |
| **상태** | ✅ **완료** |
---
## ✅ 전환 완료 내역
### 전환된 Prisma 호출 (24개)
#### 1. BatchExternalDbService (8개)
- `getAvailableConnections()` - findMany → query
- `getTables()` - $queryRaw → query (information_schema)
- `getTableColumns()` - $queryRaw → query (information_schema)
- `getExternalTables()` - findUnique → queryOne (x5)
#### 2. BatchExecutionLogService (7개)
- `getExecutionLogs()` - findMany + count → query (JOIN + 동적 WHERE)
- `createExecutionLog()` - create → queryOne (INSERT RETURNING)
- `updateExecutionLog()` - update → queryOne (동적 UPDATE)
- `deleteExecutionLog()` - delete → query
- `getLatestExecutionLog()` - findFirst → queryOne
- `getExecutionStats()` - findMany → query (동적 WHERE)
#### 3. BatchManagementService (5개)
- `getAvailableConnections()` - findMany → query
- `getTables()` - $queryRaw → query (information_schema)
- `getTableColumns()` - $queryRaw → query (information_schema)
- `getExternalTables()` - findUnique → queryOne (x2)
#### 4. BatchSchedulerService (4개)
- `loadActiveBatchConfigs()` - findMany → query (JOIN with json_agg)
- `updateBatchSchedule()` - findUnique → query (JOIN with json_agg)
- `getDataFromSource()` - $queryRawUnsafe → query
- `insertDataToTarget()` - $executeRawUnsafe → query
### 주요 기술적 해결 사항
1. **외부 DB 연결 조회 반복**
- 5개의 `findUnique` 호출을 `queryOne`으로 일괄 전환
- 암호화/복호화 로직 유지
2. **배치 설정 + 매핑 JOIN**
- Prisma `include` → `json_agg` + `json_build_object`
- `FILTER (WHERE bm.id IS NOT NULL)` 로 NULL 방지
- 계층적 JSON 데이터 생성
3. **동적 WHERE 절 생성**
- 조건부 필터링 (batch_config_id, execution_status, 날짜 범위)
- 파라미터 인덱스 동적 관리
4. **동적 UPDATE 쿼리**
- undefined 필드 제외
- 8개 필드의 조건부 업데이트
5. **통계 쿼리 전환**
- 클라이언트 사이드 집계 유지
- 원본 데이터만 쿼리로 조회
### 컴파일 상태
✅ TypeScript 컴파일 성공
✅ Linter 오류 없음
---
## 🔍 서비스별 상세 분석
### 1. BatchExternalDbService (8개 호출, 943 라인)
**주요 기능**:
- 외부 DB에서 배치 데이터 조회
- 외부 DB로 배치 데이터 저장
- 외부 DB 연결 관리
- 데이터 변환 및 매핑
**예상 Prisma 호출**:
- `getExternalDbConnection()` - 외부 DB 연결 정보 조회
- `fetchDataFromExternalDb()` - 외부 DB 데이터 조회
- `saveDataToExternalDb()` - 외부 DB 데이터 저장
- `validateExternalDbConnection()` - 연결 검증
- `getExternalDbTables()` - 테이블 목록 조회
- `getExternalDbColumns()` - 컬럼 정보 조회
- `executeBatchQuery()` - 배치 쿼리 실행
- `getBatchExecutionStatus()` - 실행 상태 조회
**기술적 고려사항**:
- 다양한 DB 타입 지원 (PostgreSQL, MySQL, Oracle, MSSQL)
- 연결 풀 관리
- 트랜잭션 처리
- 에러 핸들링 및 재시도
---
### 2. BatchExecutionLogService (7개 호출, 299 라인)
**주요 기능**:
- 배치 실행 로그 생성
- 배치 실행 이력 조회
- 배치 실행 통계
- 로그 정리
**예상 Prisma 호출**:
- `createExecutionLog()` - 실행 로그 생성
- `updateExecutionLog()` - 실행 로그 업데이트
- `getExecutionLogs()` - 실행 로그 목록 조회
- `getExecutionLogById()` - 실행 로그 단건 조회
- `getExecutionStats()` - 실행 통계 조회
- `cleanupOldLogs()` - 오래된 로그 삭제
- `getFailedExecutions()` - 실패한 실행 조회
**기술적 고려사항**:
- 대용량 로그 처리
- 통계 쿼리 최적화
- 로그 보관 정책
- 페이징 및 필터링
---
### 3. BatchManagementService (5개 호출, 373 라인)
**주요 기능**:
- 배치 작업 설정 관리
- 배치 작업 실행
- 배치 작업 중지
- 배치 작업 모니터링
**예상 Prisma 호출**:
- `getBatchJobs()` - 배치 작업 목록 조회
- `getBatchJob()` - 배치 작업 단건 조회
- `createBatchJob()` - 배치 작업 생성
- `updateBatchJob()` - 배치 작업 수정
- `deleteBatchJob()` - 배치 작업 삭제
**기술적 고려사항**:
- JSON 설정 필드 (job_config)
- 작업 상태 관리
- 동시 실행 제어
- 의존성 관리
---
### 4. BatchSchedulerService (4개 호출, 546 라인)
**주요 기능**:
- 배치 스케줄 설정
- Cron 표현식 관리
- 스케줄 실행
- 다음 실행 시간 계산
**예상 Prisma 호출**:
- `getScheduledBatches()` - 스케줄된 배치 조회
- `createSchedule()` - 스케줄 생성
- `updateSchedule()` - 스케줄 수정
- `deleteSchedule()` - 스케줄 삭제
**기술적 고려사항**:
- Cron 표현식 파싱
- 시간대 처리
- 실행 이력 추적
- 스케줄 충돌 방지
---
## 💡 통합 전환 전략
### Phase 1: 핵심 서비스 전환 (12개)
**BatchManagementService (5개) + BatchExecutionLogService (7개)**
- 배치 관리 및 로깅 기능 우선
- 상대적으로 단순한 CRUD
### Phase 2: 스케줄러 전환 (4개)
**BatchSchedulerService (4개)**
- 스케줄 관리
- Cron 표현식 처리
### Phase 3: 외부 DB 연동 전환 (8개)
**BatchExternalDbService (8개)**
- 가장 복잡한 서비스
- 외부 DB 연결 및 쿼리
---
## 💻 전환 예시
### 예시 1: 배치 실행 로그 생성
**변경 전**:
```typescript
const log = await prisma.batch_execution_logs.create({
data: {
batch_id: batchId,
status: "running",
started_at: new Date(),
execution_params: params,
company_code: companyCode,
},
});
```
**변경 후**:
```typescript
const log = await queryOne<any>(
`INSERT INTO batch_execution_logs
(batch_id, status, started_at, execution_params, company_code)
VALUES ($1, $2, NOW(), $3, $4)
RETURNING *`,
[batchId, "running", JSON.stringify(params), companyCode]
);
```
### 예시 2: 배치 통계 조회
**변경 전**:
```typescript
const stats = await prisma.batch_execution_logs.groupBy({
by: ["status"],
where: {
batch_id: batchId,
started_at: { gte: startDate, lte: endDate },
},
_count: { id: true },
});
```
**변경 후**:
```typescript
const stats = await query<{ status: string; count: string }>(
`SELECT status, COUNT(*) as count
FROM batch_execution_logs
WHERE batch_id = $1
AND started_at >= $2
AND started_at <= $3
GROUP BY status`,
[batchId, startDate, endDate]
);
```
### 예시 3: 외부 DB 연결 및 쿼리
**변경 전**:
```typescript
// 연결 정보 조회
const connection = await prisma.external_db_connections.findUnique({
where: { id: connectionId },
});
// 외부 DB 쿼리 실행 (Prisma 사용 불가, 이미 Raw Query일 가능성)
const externalData = await externalDbClient.query(sql);
```
**변경 후**:
```typescript
// 연결 정보 조회
const connection = await queryOne<any>(
`SELECT * FROM external_db_connections WHERE id = $1`,
[connectionId]
);
// 외부 DB 쿼리 실행 (기존 로직 유지)
const externalData = await externalDbClient.query(sql);
```
### 예시 4: 스케줄 관리
**변경 전**:
```typescript
const schedule = await prisma.batch_schedules.create({
data: {
batch_id: batchId,
cron_expression: cronExp,
is_active: true,
next_run_at: calculateNextRun(cronExp),
},
});
```
**변경 후**:
```typescript
const nextRun = calculateNextRun(cronExp);
const schedule = await queryOne<any>(
`INSERT INTO batch_schedules
(batch_id, cron_expression, is_active, next_run_at, created_at, updated_at)
VALUES ($1, $2, $3, $4, NOW(), NOW())
RETURNING *`,
[batchId, cronExp, true, nextRun]
);
```
---
## 🔧 기술적 고려사항
### 1. 외부 DB 연결 관리
```typescript
import { DatabaseConnectorFactory } from "../database/connectorFactory";
// 외부 DB 연결 생성
const connector = DatabaseConnectorFactory.create(connection);
const externalClient = await connector.connect();
try {
// 쿼리 실행
const result = await externalClient.query(sql, params);
} finally {
await connector.disconnect();
}
```
### 2. 트랜잭션 처리
```typescript
await transaction(async (client) => {
// 배치 상태 업데이트
await client.query(`UPDATE batch_jobs SET status = $1 WHERE id = $2`, [
"running",
batchId,
]);
// 실행 로그 생성
await client.query(
`INSERT INTO batch_execution_logs (batch_id, status, started_at)
VALUES ($1, $2, NOW())`,
[batchId, "running"]
);
});
```
### 3. Cron 표현식 처리
```typescript
import cron from "node-cron";
// Cron 표현식 검증
const isValid = cron.validate(cronExpression);
// 다음 실행 시간 계산
function calculateNextRun(cronExp: string): Date {
// Cron 파서를 사용하여 다음 실행 시간 계산
// ...
}
```
### 4. 대용량 데이터 처리
```typescript
// 스트리밍 방식으로 대용량 데이터 처리
const stream = await query<any>(
`SELECT * FROM large_table WHERE batch_id = $1`,
[batchId]
);
for await (const row of stream) {
// 행 단위 처리
}
```
---
## 📝 전환 체크리스트
### BatchExternalDbService (8개)
- [ ] `getExternalDbConnection()` - 연결 정보 조회
- [ ] `fetchDataFromExternalDb()` - 외부 DB 데이터 조회
- [ ] `saveDataToExternalDb()` - 외부 DB 데이터 저장
- [ ] `validateExternalDbConnection()` - 연결 검증
- [ ] `getExternalDbTables()` - 테이블 목록 조회
- [ ] `getExternalDbColumns()` - 컬럼 정보 조회
- [ ] `executeBatchQuery()` - 배치 쿼리 실행
- [ ] `getBatchExecutionStatus()` - 실행 상태 조회
### BatchExecutionLogService (7개)
- [ ] `createExecutionLog()` - 실행 로그 생성
- [ ] `updateExecutionLog()` - 실행 로그 업데이트
- [ ] `getExecutionLogs()` - 실행 로그 목록 조회
- [ ] `getExecutionLogById()` - 실행 로그 단건 조회
- [ ] `getExecutionStats()` - 실행 통계 조회
- [ ] `cleanupOldLogs()` - 오래된 로그 삭제
- [ ] `getFailedExecutions()` - 실패한 실행 조회
### BatchManagementService (5개)
- [ ] `getBatchJobs()` - 배치 작업 목록 조회
- [ ] `getBatchJob()` - 배치 작업 단건 조회
- [ ] `createBatchJob()` - 배치 작업 생성
- [ ] `updateBatchJob()` - 배치 작업 수정
- [ ] `deleteBatchJob()` - 배치 작업 삭제
### BatchSchedulerService (4개)
- [ ] `getScheduledBatches()` - 스케줄된 배치 조회
- [ ] `createSchedule()` - 스케줄 생성
- [ ] `updateSchedule()` - 스케줄 수정
- [ ] `deleteSchedule()` - 스케줄 삭제
### 공통 작업
- [ ] import 문 수정 (모든 서비스)
- [ ] Prisma import 완전 제거 (모든 서비스)
- [ ] 트랜잭션 로직 확인
- [ ] 에러 핸들링 검증
---
## 🧪 테스트 계획
### 단위 테스트 (24개)
- 각 Prisma 호출별 1개씩
### 통합 테스트 (8개)
- BatchExternalDbService: 외부 DB 연동 테스트 (2개)
- BatchExecutionLogService: 로그 생성 및 조회 테스트 (2개)
- BatchManagementService: 배치 작업 실행 테스트 (2개)
- BatchSchedulerService: 스케줄 실행 테스트 (2개)
### 성능 테스트
- 대용량 데이터 처리 성능
- 동시 배치 실행 성능
- 외부 DB 연결 풀 성능
---
## 🎯 예상 난이도 및 소요 시간
- **난이도**: ⭐⭐⭐⭐⭐ (매우 높음)
- 외부 DB 연동
- 트랜잭션 처리
- 스케줄링 로직
- 대용량 데이터 처리
- **예상 소요 시간**: 4~5시간
- Phase 1 (BatchManagement + ExecutionLog): 1.5시간
- Phase 2 (Scheduler): 1시간
- Phase 3 (ExternalDb): 2시간
- 테스트 및 문서화: 0.5시간
---
## ⚠️ 주의사항
### 중요 체크포인트
1. ✅ 외부 DB 연결은 반드시 try-finally에서 해제
2. ✅ 배치 실행 중 에러 시 롤백 처리
3. ✅ Cron 표현식 검증 필수
4. ✅ 대용량 데이터는 스트리밍 방식 사용
5. ✅ 동시 실행 제한 확인
### 성능 최적화
- 연결 풀 활용
- 배치 쿼리 최적화
- 인덱스 확인
- 불필요한 로그 제거
---
**상태**: ⏳ **대기 중**
**특이사항**: 외부 DB 연동, 스케줄링, 트랜잭션 처리 포함
**⚠️ 주의**: 배치 시스템의 핵심 기능이므로 신중한 테스트 필수!

540
PHASE3.16_DATA_MANAGEMENT_SERVICES_MIGRATION.md Normal file
View File

@ -0,0 +1,540 @@
# 📋 Phase 3.16: Data Management Services Raw Query 전환 계획
## 📋 개요
데이터 관리 관련 서비스들은 총 **18개의 Prisma 호출**이 있으며, 동적 폼, 데이터 매핑, 데이터 서비스, 관리자 기능을 담당합니다.
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | ----------------------------------------------------- |
| 대상 서비스 | 4개 (EnhancedDynamicForm, DataMapping, Data, Admin) |
| 파일 위치 | `backend-node/src/services/{enhanced,data,admin}*.ts` |
| 총 파일 크기 | 2,062 라인 |
| Prisma 호출 | 0개 (전환 완료) |
| **현재 진행률** | **18/18 (100%)** ✅ **전환 완료** |
| 복잡도 | 중간 (동적 쿼리, JSON 필드, 관리자 기능) |
| 우선순위 | 🟡 중간 (Phase 3.16) |
| **상태** | ✅ **완료** |
---
## ✅ 전환 완료 내역
### 전환된 Prisma 호출 (18개)
#### 1. EnhancedDynamicFormService (6개)
- `validateTableExists()` - $queryRawUnsafe → query
- `getTableColumns()` - $queryRawUnsafe → query
- `getColumnWebTypes()` - $queryRawUnsafe → query
- `getPrimaryKeys()` - $queryRawUnsafe → query
- `performInsert()` - $queryRawUnsafe → query
- `performUpdate()` - $queryRawUnsafe → query
#### 2. DataMappingService (5개)
- `getSourceData()` - $queryRawUnsafe → query
- `executeInsert()` - $executeRawUnsafe → query
- `executeUpsert()` - $executeRawUnsafe → query
- `executeUpdate()` - $executeRawUnsafe → query
- `disconnect()` - 제거 (Raw Query는 disconnect 불필요)
#### 3. DataService (4개)
- `getTableData()` - $queryRawUnsafe → query
- `checkTableExists()` - $queryRawUnsafe → query
- `getTableColumnsSimple()` - $queryRawUnsafe → query
- `getColumnLabel()` - $queryRawUnsafe → query
#### 4. AdminService (3개)
- `getAdminMenuList()` - $queryRaw → query (WITH RECURSIVE)
- `getUserMenuList()` - $queryRaw → query (WITH RECURSIVE)
- `getMenuInfo()` - findUnique → query (JOIN)
### 주요 기술적 해결 사항
1. **변수명 충돌 해결**
- `dataService.ts`에서 `query` 변수 → `sql` 변수로 변경
- `query()` 함수와 로컬 변수 충돌 방지
2. **WITH RECURSIVE 쿼리 전환**
- Prisma의 `$queryRaw` 템플릿 리터럴 → 일반 문자열
- `${userLang}` → `$1` 파라미터 바인딩
3. **JOIN 쿼리 전환**
- Prisma의 `include` 옵션 → `LEFT JOIN` 쿼리
- 관계 데이터를 단일 쿼리로 조회
4. **동적 쿼리 생성**
- 동적 WHERE 조건 구성
- SQL 인젝션 방지 (컬럼명 검증)
- 동적 ORDER BY 처리
### 컴파일 상태
✅ TypeScript 컴파일 성공
✅ Linter 오류 없음
---
## 🔍 서비스별 상세 분석
### 1. EnhancedDynamicFormService (6개 호출, 786 라인)
**주요 기능**:
- 고급 동적 폼 관리
- 폼 검증 규칙
- 조건부 필드 표시
- 폼 템플릿 관리
**예상 Prisma 호출**:
- `getEnhancedForms()` - 고급 폼 목록 조회
- `getEnhancedForm()` - 고급 폼 단건 조회
- `createEnhancedForm()` - 고급 폼 생성
- `updateEnhancedForm()` - 고급 폼 수정
- `deleteEnhancedForm()` - 고급 폼 삭제
- `getFormValidationRules()` - 검증 규칙 조회
**기술적 고려사항**:
- JSON 필드 (validation_rules, conditional_logic, field_config)
- 복잡한 검증 규칙
- 동적 필드 생성
- 조건부 표시 로직
---
### 2. DataMappingService (5개 호출, 575 라인)
**주요 기능**:
- 데이터 매핑 설정 관리
- 소스-타겟 필드 매핑
- 데이터 변환 규칙
- 매핑 실행
**예상 Prisma 호출**:
- `getDataMappings()` - 매핑 설정 목록 조회
- `getDataMapping()` - 매핑 설정 단건 조회
- `createDataMapping()` - 매핑 설정 생성
- `updateDataMapping()` - 매핑 설정 수정
- `deleteDataMapping()` - 매핑 설정 삭제
**기술적 고려사항**:
- JSON 필드 (field_mappings, transformation_rules)
- 복잡한 변환 로직
- 매핑 검증
- 실행 이력 추적
---
### 3. DataService (4개 호출, 327 라인)
**주요 기능**:
- 동적 데이터 조회
- 데이터 필터링
- 데이터 정렬
- 데이터 집계
**예상 Prisma 호출**:
- `getDataByTable()` - 테이블별 데이터 조회
- `getDataById()` - 데이터 단건 조회
- `executeCustomQuery()` - 커스텀 쿼리 실행
- `getDataStatistics()` - 데이터 통계 조회
**기술적 고려사항**:
- 동적 테이블 쿼리
- SQL 인젝션 방지
- 동적 WHERE 조건
- 집계 쿼리
---
### 4. AdminService (3개 호출, 374 라인)
**주요 기능**:
- 관리자 메뉴 관리
- 시스템 설정
- 사용자 관리
- 로그 조회
**예상 Prisma 호출**:
- `getAdminMenus()` - 관리자 메뉴 조회
- `getSystemSettings()` - 시스템 설정 조회
- `updateSystemSettings()` - 시스템 설정 업데이트
**기술적 고려사항**:
- 메뉴 계층 구조
- 권한 기반 필터링
- JSON 설정 필드
- 캐싱
---
## 💡 통합 전환 전략
### Phase 1: 단순 CRUD 전환 (12개)
**EnhancedDynamicFormService (6개) + DataMappingService (5개) + AdminService (1개)**
- 기본 CRUD 기능
- JSON 필드 처리
### Phase 2: 동적 쿼리 전환 (4개)
**DataService (4개)**
- 동적 테이블 쿼리
- 보안 검증
### Phase 3: 고급 기능 전환 (2개)
**AdminService (2개)**
- 시스템 설정
- 캐싱
---
## 💻 전환 예시
### 예시 1: 고급 폼 생성 (JSON 필드)
**변경 전**:
```typescript
const form = await prisma.enhanced_forms.create({
data: {
form_code: formCode,
form_name: formName,
validation_rules: validationRules, // JSON
conditional_logic: conditionalLogic, // JSON
field_config: fieldConfig, // JSON
company_code: companyCode,
},
});
```
**변경 후**:
```typescript
const form = await queryOne<any>(
`INSERT INTO enhanced_forms
(form_code, form_name, validation_rules, conditional_logic,
field_config, company_code, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW())
RETURNING *`,
[
formCode,
formName,
JSON.stringify(validationRules),
JSON.stringify(conditionalLogic),
JSON.stringify(fieldConfig),
companyCode,
]
);
```
### 예시 2: 데이터 매핑 조회
**변경 전**:
```typescript
const mappings = await prisma.data_mappings.findMany({
where: {
source_table: sourceTable,
target_table: targetTable,
is_active: true,
},
include: {
source_columns: true,
target_columns: true,
},
});
```
**변경 후**:
```typescript
const mappings = await query<any>(
`SELECT
dm.*,
json_agg(DISTINCT jsonb_build_object(
'column_id', sc.column_id,
'column_name', sc.column_name
)) FILTER (WHERE sc.column_id IS NOT NULL) as source_columns,
json_agg(DISTINCT jsonb_build_object(
'column_id', tc.column_id,
'column_name', tc.column_name
)) FILTER (WHERE tc.column_id IS NOT NULL) as target_columns
FROM data_mappings dm
LEFT JOIN columns sc ON dm.mapping_id = sc.mapping_id AND sc.type = 'source'
LEFT JOIN columns tc ON dm.mapping_id = tc.mapping_id AND tc.type = 'target'
WHERE dm.source_table = $1
AND dm.target_table = $2
AND dm.is_active = $3
GROUP BY dm.mapping_id`,
[sourceTable, targetTable, true]
);
```
### 예시 3: 동적 테이블 쿼리 (DataService)
**변경 전**:
```typescript
// Prisma로는 동적 테이블 쿼리 불가능
// 이미 $queryRawUnsafe 사용 중일 가능성
const data = await prisma.$queryRawUnsafe(
`SELECT * FROM ${tableName} WHERE ${whereClause}`,
...params
);
```
**변경 후**:
```typescript
// SQL 인젝션 방지를 위한 테이블명 검증
const validTableName = validateTableName(tableName);
const data = await query<any>(
`SELECT * FROM ${validTableName} WHERE ${whereClause}`,
params
);
```
### 예시 4: 관리자 메뉴 조회 (계층 구조)
**변경 전**:
```typescript
const menus = await prisma.admin_menus.findMany({
where: { is_active: true },
orderBy: { sort_order: "asc" },
include: {
children: {
orderBy: { sort_order: "asc" },
},
},
});
```
**변경 후**:
```typescript
// 재귀 CTE를 사용한 계층 쿼리
const menus = await query<any>(
`WITH RECURSIVE menu_tree AS (
SELECT *, 0 as level, ARRAY[menu_id] as path
FROM admin_menus
WHERE parent_id IS NULL AND is_active = $1
UNION ALL
SELECT m.*, mt.level + 1, mt.path || m.menu_id
FROM admin_menus m
JOIN menu_tree mt ON m.parent_id = mt.menu_id
WHERE m.is_active = $1
)
SELECT * FROM menu_tree
ORDER BY path, sort_order`,
[true]
);
```
---
## 🔧 기술적 고려사항
### 1. JSON 필드 처리
```typescript
// 복잡한 JSON 구조
interface ValidationRules {
required?: string[];
min?: Record<string, number>;
max?: Record<string, number>;
pattern?: Record<string, string>;
custom?: Array<{ field: string; rule: string }>;
}
// 저장 시
JSON.stringify(validationRules);
// 조회 후
const parsed =
typeof row.validation_rules === "string"
? JSON.parse(row.validation_rules)
: row.validation_rules;
```
### 2. 동적 테이블 쿼리 보안
```typescript
// 테이블명 화이트리스트
const ALLOWED_TABLES = ["users", "products", "orders"];
function validateTableName(tableName: string): string {
if (!ALLOWED_TABLES.includes(tableName)) {
throw new Error("Invalid table name");
}
return tableName;
}
// 컬럼명 검증
function validateColumnName(columnName: string): string {
if (!/^[a-z_][a-z0-9_]*$/i.test(columnName)) {
throw new Error("Invalid column name");
}
return columnName;
}
```
### 3. 재귀 CTE (계층 구조)
```sql
WITH RECURSIVE hierarchy AS (
-- 최상위 노드
SELECT * FROM table WHERE parent_id IS NULL
UNION ALL
-- 하위 노드
SELECT t.* FROM table t
JOIN hierarchy h ON t.parent_id = h.id
)
SELECT * FROM hierarchy
```
### 4. JSON 집계 (관계 데이터)
```sql
SELECT
parent.*,
COALESCE(
json_agg(
jsonb_build_object('id', child.id, 'name', child.name)
) FILTER (WHERE child.id IS NOT NULL),
'[]'
) as children
FROM parent
LEFT JOIN child ON parent.id = child.parent_id
GROUP BY parent.id
```
---
## 📝 전환 체크리스트
### EnhancedDynamicFormService (6개)
- [ ] `getEnhancedForms()` - 목록 조회
- [ ] `getEnhancedForm()` - 단건 조회
- [ ] `createEnhancedForm()` - 생성 (JSON 필드)
- [ ] `updateEnhancedForm()` - 수정 (JSON 필드)
- [ ] `deleteEnhancedForm()` - 삭제
- [ ] `getFormValidationRules()` - 검증 규칙 조회
### DataMappingService (5개)
- [ ] `getDataMappings()` - 목록 조회
- [ ] `getDataMapping()` - 단건 조회
- [ ] `createDataMapping()` - 생성
- [ ] `updateDataMapping()` - 수정
- [ ] `deleteDataMapping()` - 삭제
### DataService (4개)
- [ ] `getDataByTable()` - 동적 테이블 조회
- [ ] `getDataById()` - 단건 조회
- [ ] `executeCustomQuery()` - 커스텀 쿼리
- [ ] `getDataStatistics()` - 통계 조회
### AdminService (3개)
- [ ] `getAdminMenus()` - 메뉴 조회 (재귀 CTE)
- [ ] `getSystemSettings()` - 시스템 설정 조회
- [ ] `updateSystemSettings()` - 시스템 설정 업데이트
### 공통 작업
- [ ] import 문 수정 (모든 서비스)
- [ ] Prisma import 완전 제거
- [ ] JSON 필드 처리 확인
- [ ] 보안 검증 (SQL 인젝션)
---
## 🧪 테스트 계획
### 단위 테스트 (18개)
- 각 Prisma 호출별 1개씩
### 통합 테스트 (6개)
- EnhancedDynamicFormService: 폼 생성 및 검증 테스트 (2개)
- DataMappingService: 매핑 설정 및 실행 테스트 (2개)
- DataService: 동적 쿼리 및 보안 테스트 (1개)
- AdminService: 메뉴 계층 구조 테스트 (1개)
### 보안 테스트
- SQL 인젝션 방지 테스트
- 테이블명 검증 테스트
- 컬럼명 검증 테스트
---
## 🎯 예상 난이도 및 소요 시간
- **난이도**: ⭐⭐⭐⭐ (높음)
- JSON 필드 처리
- 동적 쿼리 보안
- 재귀 CTE
- JSON 집계
- **예상 소요 시간**: 2.5~3시간
- Phase 1 (기본 CRUD): 1시간
- Phase 2 (동적 쿼리): 1시간
- Phase 3 (고급 기능): 0.5시간
- 테스트 및 문서화: 0.5시간
---
## ⚠️ 주의사항
### 보안 필수 체크리스트
1. ✅ 동적 테이블명은 반드시 화이트리스트 검증
2. ✅ 동적 컬럼명은 정규식으로 검증
3. ✅ WHERE 절 파라미터는 반드시 바인딩
4. ✅ JSON 필드는 파싱 에러 처리
5. ✅ 재귀 쿼리는 깊이 제한 설정
### 성능 최적화
- JSON 필드 인덱싱 (GIN 인덱스)
- 재귀 쿼리 깊이 제한
- 집계 쿼리 최적화
- 필요시 캐싱 적용
---
**상태**: ⏳ **대기 중**
**특이사항**: JSON 필드, 동적 쿼리, 재귀 CTE, 보안 검증 포함
**⚠️ 주의**: 동적 쿼리는 SQL 인젝션 방지가 매우 중요!

62
PHASE3.17_REFERENCE_CACHE_SERVICE_MIGRATION.md Normal file
View File

@ -0,0 +1,62 @@
# 📋 Phase 3.17: ReferenceCacheService Raw Query 전환 계획
## 📋 개요
ReferenceCacheService는 **0개의 Prisma 호출**이 있으며, 참조 데이터 캐싱을 담당하는 서비스입니다.
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | ---------------------------------------------------- |
| 파일 위치 | `backend-node/src/services/referenceCacheService.ts` |
| 파일 크기 | 499 라인 |
| Prisma 호출 | 0개 (이미 전환 완료) |
| **현재 진행률** | **3/3 (100%)** ✅ **전환 완료** |
| 복잡도 | 낮음 (캐싱 로직) |
| 우선순위 | 🟢 낮음 (Phase 3.17) |
| **상태** | ✅ **완료** (이미 전환 완료됨) |
---
## ✅ 전환 완료 내역 (이미 완료됨)
ReferenceCacheService는 이미 Raw Query로 전환이 완료되었습니다.
### 주요 기능
1. **참조 데이터 캐싱**
- 자주 사용되는 참조 테이블 데이터를 메모리에 캐싱
- 성능 향상을 위한 캐시 전략
2. **캐시 관리**
- 캐시 갱신 로직
- TTL(Time To Live) 관리
- 캐시 무효화
3. **데이터 조회 최적화**
- 캐시 히트/미스 처리
- 백그라운드 갱신
### 기술적 특징
- **메모리 캐싱**: Map/Object 기반 인메모리 캐싱
- **성능 최적화**: 반복 DB 조회 최소화
- **자동 갱신**: 주기적 캐시 갱신 로직
### 코드 상태
- [x] Prisma import 없음
- [x] query 함수 사용 중
- [x] TypeScript 컴파일 성공
- [x] 캐싱 로직 정상 동작
---
## 📝 비고
이 서비스는 이미 Raw Query로 전환이 완료되어 있어 추가 작업이 필요하지 않습니다.
**상태**: ✅ **완료**
**특이사항**: 캐싱 로직으로 성능에 중요한 서비스

92
PHASE3.18_DDL_EXECUTION_SERVICE_MIGRATION.md Normal file
View File

@ -0,0 +1,92 @@
# 📋 Phase 3.18: DDLExecutionService Raw Query 전환 계획
## 📋 개요
DDLExecutionService는 **0개의 Prisma 호출**이 있으며, DDL 실행 및 관리를 담당하는 서비스입니다.
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | -------------------------------------------------- |
| 파일 위치 | `backend-node/src/services/ddlExecutionService.ts` |
| 파일 크기 | 786 라인 |
| Prisma 호출 | 0개 (이미 전환 완료) |
| **현재 진행률** | **6/6 (100%)** ✅ **전환 완료** |
| 복잡도 | 높음 (DDL 실행, 안전성 검증) |
| 우선순위 | 🔴 높음 (Phase 3.18) |
| **상태** | ✅ **완료** (이미 전환 완료됨) |
---
## ✅ 전환 완료 내역 (이미 완료됨)
DDLExecutionService는 이미 Raw Query로 전환이 완료되었습니다.
### 주요 기능
1. **테이블 생성 (CREATE TABLE)**
- 동적 테이블 생성
- 컬럼 정의 및 제약조건
- 인덱스 생성
2. **컬럼 추가 (ADD COLUMN)**
- 기존 테이블에 컬럼 추가
- 데이터 타입 검증
- 기본값 설정
3. **테이블/컬럼 삭제 (DROP)**
- 안전한 삭제 검증
- 의존성 체크
- 롤백 가능성
4. **DDL 안전성 검증**
- DDL 실행 전 검증
- 순환 참조 방지
- 데이터 손실 방지
5. **DDL 실행 이력**
- 모든 DDL 실행 기록
- 성공/실패 로그
- 롤백 정보
6. **트랜잭션 관리**
- DDL 트랜잭션 처리
- 에러 시 롤백
- 일관성 유지
### 기술적 특징
- **동적 DDL 생성**: 파라미터 기반 DDL 쿼리 생성
- **안전성 검증**: 실행 전 다중 검증 단계
- **감사 로깅**: DDLAuditLogger와 연동
- **PostgreSQL 특화**: PostgreSQL DDL 문법 활용
### 보안 및 안전성
- **SQL 인젝션 방지**: 테이블/컬럼명 화이트리스트 검증
- **권한 검증**: 사용자 권한 확인
- **백업 권장**: DDL 실행 전 백업 체크
- **복구 가능성**: 실행 이력 기록
### 코드 상태
- [x] Prisma import 없음
- [x] query 함수 사용 중
- [x] TypeScript 컴파일 성공
- [x] 안전성 검증 로직 유지
- [x] DDLAuditLogger 연동
---
## 📝 비고
이 서비스는 이미 Raw Query로 전환이 완료되어 있어 추가 작업이 필요하지 않습니다.
**상태**: ✅ **완료**
**특이사항**: DDL 실행의 핵심 서비스로 안전성이 매우 중요
**⚠️ 주의**: 프로덕션 환경에서 DDL 실행 시 각별한 주의 필요

47
PHASE3.9_TEMPLATE_STANDARD_SERVICE_MIGRATION.md
View File

@ -6,23 +6,25 @@ TemplateStandardService는 **6개의 Prisma 호출**이 있으며, 템플릿 표
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | ----------------------------------------------------------- |
| 파일 위치 | `backend-node/src/services/templateStandardService.ts` |
| 파일 크기 | 395 라인 |
| Prisma 호출 | 6개 |
| **현재 진행률** | **0/6 (0%)** 🔄 **진행 예정** |
| 복잡도 | 낮음 (기본 CRUD + DISTINCT) |
| 우선순위 | 🟢 낮음 (Phase 3.9) |
| **상태** | ⏳ **대기 중** |
| 항목 | 내용 |
| --------------- | ------------------------------------------------------ |
| 파일 위치 | `backend-node/src/services/templateStandardService.ts` |
| 파일 크기 | 395 라인 |
| Prisma 호출 | 6개 |
| **현재 진행률** | **7/7 (100%)** ✅ **전환 완료** |
| 복잡도 | 낮음 (기본 CRUD + DISTINCT) |
| 우선순위 | 🟢 낮음 (Phase 3.9) |
| **상태** | ✅ **완료** |
### 🎯 전환 목표
- ⏳ **6개 모든 Prisma 호출을 `db.ts`의 `query()`, `queryOne()` 함수로 교체**
- ⏳ 템플릿 CRUD 기능 정상 동작
- ⏳ DISTINCT 쿼리 전환
- ⏳ 모든 단위 테스트 통과
- ⏳ **Prisma import 완전 제거**
- ✅ **7개 모든 Prisma 호출을 `db.ts`의 `query()`, `queryOne()` 함수로 교체**
- ✅ 템플릿 CRUD 기능 정상 동작
- ✅ DISTINCT 쿼리 전환
- ✅ Promise.all 병렬 쿼리 (목록 + 개수)
- ✅ 동적 UPDATE 쿼리 (11개 필드)
- ✅ TypeScript 컴파일 성공
- ✅ **Prisma import 완전 제거**
---
@ -31,6 +33,7 @@ TemplateStandardService는 **6개의 Prisma 호출**이 있으며, 템플릿 표
### 주요 Prisma 호출 (6개)
#### 1. **getTemplateByCode()** - 템플릿 단건 조회
```typescript
// Line 76
return await prisma.template_standards.findUnique({
@ -42,6 +45,7 @@ return await prisma.template_standards.findUnique({
```
#### 2. **createTemplate()** - 템플릿 생성
```typescript
// Line 86
const existing = await prisma.template_standards.findUnique({
@ -62,6 +66,7 @@ return await prisma.template_standards.create({
```
#### 3. **updateTemplate()** - 템플릿 수정
```typescript
// Line 164
return await prisma.template_standards.update({
@ -79,6 +84,7 @@ return await prisma.template_standards.update({
```
#### 4. **deleteTemplate()** - 템플릿 삭제
```typescript
// Line 181
await prisma.template_standards.delete({
@ -92,6 +98,7 @@ await prisma.template_standards.delete({
```
#### 5. **getTemplateCategories()** - 카테고리 목록 (DISTINCT)
```typescript
// Line 262
const categories = await prisma.template_standards.findMany({
@ -112,6 +119,7 @@ const categories = await prisma.template_standards.findMany({
### 1단계: 기본 CRUD 전환 (4개 함수)
**함수 목록**:
- `getTemplateByCode()` - 단건 조회 (findUnique)
- `createTemplate()` - 생성 (findUnique + create)
- `updateTemplate()` - 수정 (update)
@ -120,6 +128,7 @@ const categories = await prisma.template_standards.findMany({
### 2단계: 추가 기능 전환 (1개 함수)
**함수 목록**:
- `getTemplateCategories()` - 카테고리 목록 (findMany + distinct)
---
@ -337,14 +346,18 @@ return categories.map((c) => c.category);
## 🔧 주요 기술적 과제
### 1. 복합 기본 키
`template_standards` 테이블은 `(template_code, company_code)` 복합 기본 키를 사용합니다.
- WHERE 절에서 두 컬럼 모두 지정 필요
- Prisma의 `template_code_company_code` 표현식을 `template_code = $1 AND company_code = $2`로 변환
### 2. JSON 필드
`layout_config` 필드는 JSON 타입으로, INSERT/UPDATE 시 `JSON.stringify()` 필요합니다.
### 3. DISTINCT + NULL 제외
카테고리 목록 조회 시 `DISTINCT` 사용하며, NULL 값은 `WHERE category IS NOT NULL`로 제외합니다.
---
@ -352,6 +365,7 @@ return categories.map((c) => c.category);
## 📋 체크리스트
### 코드 전환
- [ ] import 문 수정 (`prisma` → `query, queryOne`)
- [ ] getTemplateByCode() - findUnique → queryOne (복합 키)
- [ ] createTemplate() - findUnique + create → queryOne (중복 확인 + INSERT)
@ -362,6 +376,7 @@ return categories.map((c) => c.category);
- [ ] Prisma import 완전 제거
### 테스트
- [ ] 단위 테스트 작성 (6개)
- [ ] 통합 테스트 작성 (2개)
- [ ] TypeScript 컴파일 성공
@ -372,12 +387,15 @@ return categories.map((c) => c.category);
## 💡 특이사항
### 복합 기본 키 패턴
이 서비스는 `(template_code, company_code)` 복합 기본 키를 사용하므로, 모든 조회/수정/삭제 작업에서 두 컬럼을 모두 WHERE 조건에 포함해야 합니다.
### JSON 레이아웃 설정
`layout_config` 필드는 템플릿의 레이아웃 설정을 JSON 형태로 저장합니다. Raw Query 전환 시 `JSON.stringify()`를 사용하여 문자열로 변환해야 합니다.
### 카테고리 관리
템플릿은 카테고리별로 분류되며, `getTemplateCategories()` 메서드로 고유한 카테고리 목록을 조회할 수 있습니다.
---
@ -388,4 +406,3 @@ return categories.map((c) => c.category);
**우선순위**: 🟢 낮음 (Phase 3.9)
**상태**: ⏳ **대기 중**
**특이사항**: 복합 기본 키, JSON 필드, DISTINCT 쿼리 포함

522
PHASE4.1_ADMIN_CONTROLLER_MIGRATION.md Normal file
View File

@ -0,0 +1,522 @@
# Phase 4.1: AdminController Raw Query 전환 계획
## 📋 개요
관리자 컨트롤러의 Prisma 호출을 Raw Query로 전환합니다.
사용자, 회사, 부서, 메뉴 관리 등 핵심 관리 기능을 포함합니다.
---
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | ------------------------------------------------- |
| 파일 위치 | `backend-node/src/controllers/adminController.ts` |
| 파일 크기 | 2,569 라인 |
| Prisma 호출 | 28개 → 0개 |
| **현재 진행률** | **28/28 (100%)** ✅ **완료** |
| 복잡도 | 중간 (다양한 CRUD 패턴) |
| 우선순위 | 🔴 높음 (Phase 4.1) |
| **상태** | ✅ **완료** (2025-10-01) |
---
## 🔍 Prisma 호출 분석
### 사용자 관리 (13개)
#### 1. getUserList (라인 312-317)
```typescript
const totalCount = await prisma.user_info.count({ where });
const users = await prisma.user_info.findMany({ where, skip, take, orderBy });
```
- **전환**: count → `queryOne`, findMany → `query`
- **복잡도**: 중간 (동적 WHERE, 페이징)
#### 2. getUserInfo (라인 419)
```typescript
const userInfo = await prisma.user_info.findFirst({ where });
```
- **전환**: findFirst → `queryOne`
- **복잡도**: 낮음
#### 3. updateUserStatus (라인 498)
```typescript
await prisma.user_info.update({ where, data });
```
- **전환**: update → `query`
- **복잡도**: 낮음
#### 4. deleteUserByAdmin (라인 2387)
```typescript
await prisma.user_info.update({ where, data: { is_active: "N" } });
```
- **전환**: update (soft delete) → `query`
- **복잡도**: 낮음
#### 5. getMyProfile (라인 1468, 1488, 2479)
```typescript
const user = await prisma.user_info.findUnique({ where });
const dept = await prisma.dept_info.findUnique({ where });
```
- **전환**: findUnique → `queryOne`
- **복잡도**: 낮음
#### 6. updateMyProfile (라인 1864, 2527)
```typescript
const updateResult = await prisma.user_info.update({ where, data });
```
- **전환**: update → `queryOne` with RETURNING
- **복잡도**: 중간 (동적 UPDATE)
#### 7. createOrUpdateUser (라인 1929, 1975)
```typescript
const savedUser = await prisma.user_info.upsert({ where, update, create });
const userCount = await prisma.user_info.count({ where });
```
- **전환**: upsert → `INSERT ... ON CONFLICT`, count → `queryOne`
- **복잡도**: 높음
#### 8. 기타 findUnique (라인 1596, 1832, 2393)
```typescript
const existingUser = await prisma.user_info.findUnique({ where });
const currentUser = await prisma.user_info.findUnique({ where });
const updatedUser = await prisma.user_info.findUnique({ where });
```
- **전환**: findUnique → `queryOne`
- **복잡도**: 낮음
### 회사 관리 (7개)
#### 9. getCompanyList (라인 550, 1276)
```typescript
const companies = await prisma.company_mng.findMany({ orderBy });
```
- **전환**: findMany → `query`
- **복잡도**: 낮음
#### 10. createCompany (라인 2035)
```typescript
const existingCompany = await prisma.company_mng.findFirst({ where });
```
- **전환**: findFirst (중복 체크) → `queryOne`
- **복잡도**: 낮음
#### 11. updateCompany (라인 2172, 2192)
```typescript
const duplicateCompany = await prisma.company_mng.findFirst({ where });
const updatedCompany = await prisma.company_mng.update({ where, data });
```
- **전환**: findFirst → `queryOne`, update → `queryOne`
- **복잡도**: 중간
#### 12. deleteCompany (라인 2261, 2281)
```typescript
const existingCompany = await prisma.company_mng.findUnique({ where });
await prisma.company_mng.delete({ where });
```
- **전환**: findUnique → `queryOne`, delete → `query`
- **복잡도**: 낮음
### 부서 관리 (2개)
#### 13. getDepartmentList (라인 1348)
```typescript
const departments = await prisma.dept_info.findMany({ where, orderBy });
```
- **전환**: findMany → `query`
- **복잡도**: 낮음
#### 14. getDeptInfo (라인 1488)
```typescript
const dept = await prisma.dept_info.findUnique({ where });
```
- **전환**: findUnique → `queryOne`
- **복잡도**: 낮음
### 메뉴 관리 (3개)
#### 15. createMenu (라인 1021)
```typescript
const savedMenu = await prisma.menu_info.create({ data });
```
- **전환**: create → `queryOne` with INSERT RETURNING
- **복잡도**: 중간
#### 16. updateMenu (라인 1087)
```typescript
const updatedMenu = await prisma.menu_info.update({ where, data });
```
- **전환**: update → `queryOne` with UPDATE RETURNING
- **복잡도**: 중간
#### 17. deleteMenu (라인 1149, 1211)
```typescript
const deletedMenu = await prisma.menu_info.delete({ where });
// 재귀 삭제
const deletedMenu = await prisma.menu_info.delete({ where });
```
- **전환**: delete → `query`
- **복잡도**: 중간 (재귀 삭제 로직)
### 다국어 (1개)
#### 18. getMultiLangKeys (라인 665)
```typescript
const result = await prisma.multi_lang_key_master.findMany({ where, orderBy });
```
- **전환**: findMany → `query`
- **복잡도**: 낮음
---
## 📝 전환 전략
### 1단계: Import 변경
```typescript
// 제거
import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient();
// 추가
import { query, queryOne } from "../database/db";
```
### 2단계: 단순 조회 전환
- findMany → `query<T>`
- findUnique/findFirst → `queryOne<T>`
### 3단계: 동적 WHERE 처리
```typescript
const whereConditions: string[] = [];
const params: any[] = [];
let paramIndex = 1;
if (companyCode) {
whereConditions.push(`company_code = $${paramIndex++}`);
params.push(companyCode);
}
const whereClause =
whereConditions.length > 0 ? `WHERE ${whereConditions.join(" AND ")}` : "";
```
### 4단계: 복잡한 로직 전환
- count → `SELECT COUNT(*) as count`
- upsert → `INSERT ... ON CONFLICT DO UPDATE`
- 동적 UPDATE → 조건부 SET 절 생성
### 5단계: 테스트 및 검증
- 각 함수별 동작 확인
- 에러 처리 확인
- 타입 안전성 확인
---
## 🎯 주요 변경 예시
### getUserList (count + findMany)
```typescript
// Before
const totalCount = await prisma.user_info.count({ where });
const users = await prisma.user_info.findMany({
where,
skip,
take,
orderBy,
});
// After
const whereConditions: string[] = [];
const params: any[] = [];
let paramIndex = 1;
// 동적 WHERE 구성
if (where.company_code) {
whereConditions.push(`company_code = $${paramIndex++}`);
params.push(where.company_code);
}
if (where.user_name) {
whereConditions.push(`user_name ILIKE $${paramIndex++}`);
params.push(`%${where.user_name}%`);
}
const whereClause =
whereConditions.length > 0 ? `WHERE ${whereConditions.join(" AND ")}` : "";
// Count
const countResult = await queryOne<{ count: number }>(
`SELECT COUNT(*) as count FROM user_info ${whereClause}`,
params
);
const totalCount = parseInt(countResult?.count?.toString() || "0", 10);
// 데이터 조회
const usersQuery = `
SELECT * FROM user_info
${whereClause}
ORDER BY created_date DESC
LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
`;
params.push(take, skip);
const users = await query<UserInfo>(usersQuery, params);
```
### createOrUpdateUser (upsert)
```typescript
// Before
const savedUser = await prisma.user_info.upsert({
where: { user_id: userId },
update: updateData,
create: createData
});
// After
const savedUser = await queryOne<UserInfo>(
`INSERT INTO user_info (user_id, user_name, email, ...)
VALUES ($1, $2, $3, ...)
ON CONFLICT (user_id)
DO UPDATE SET
user_name = EXCLUDED.user_name,
email = EXCLUDED.email,
...
RETURNING *`,
[userId, userName, email, ...]
);
```
### updateMyProfile (동적 UPDATE)
```typescript
// Before
const updateResult = await prisma.user_info.update({
where: { user_id: userId },
data: updateData,
});
// After
const updates: string[] = [];
const params: any[] = [];
let paramIndex = 1;
if (updateData.user_name !== undefined) {
updates.push(`user_name = $${paramIndex++}`);
params.push(updateData.user_name);
}
if (updateData.email !== undefined) {
updates.push(`email = $${paramIndex++}`);
params.push(updateData.email);
}
// ... 다른 필드들
params.push(userId);
const updateResult = await queryOne<UserInfo>(
`UPDATE user_info
SET ${updates.join(", ")}, updated_date = NOW()
WHERE user_id = $${paramIndex}
RETURNING *`,
params
);
```
---
## ✅ 체크리스트
### 기본 설정
- ✅ Prisma import 제거 (완전 제거 확인)
- ✅ query, queryOne import 추가 (이미 존재)
- ✅ 타입 import 확인
### 사용자 관리
- ✅ getUserList (count + findMany → Raw Query)
- ✅ getUserLocale (findFirst → queryOne)
- ✅ setUserLocale (update → query)
- ✅ getUserInfo (findUnique → queryOne)
- ✅ checkDuplicateUserId (findUnique → queryOne)
- ✅ changeUserStatus (findUnique + update → queryOne + query)
- ✅ saveUser (upsert → INSERT ON CONFLICT)
- ✅ updateProfile (동적 update → 동적 query)
- ✅ resetUserPassword (update → query)
### 회사 관리
- ✅ getCompanyList (findMany → query)
- ✅ getCompanyListFromDB (findMany → query)
- ✅ createCompany (findFirst → queryOne)
- ✅ updateCompany (findFirst + update → queryOne + query)
- ✅ deleteCompany (delete → query with RETURNING)
### 부서 관리
- ✅ getDepartmentList (findMany → query with 동적 WHERE)
### 메뉴 관리
- ✅ saveMenu (create → query with INSERT RETURNING)
- ✅ updateMenu (update → query with UPDATE RETURNING)
- ✅ deleteMenu (delete → query with DELETE RETURNING)
- ✅ deleteMenusBatch (다중 delete → 반복 query)
### 다국어
- ✅ getLangKeyList (findMany → query)
### 검증
- ✅ TypeScript 컴파일 확인 (에러 없음)
- ✅ Linter 오류 확인
- ⏳ 기능 테스트 (실행 필요)
- ✅ 에러 처리 확인 (기존 구조 유지)
---
## 📌 참고사항
### 동적 쿼리 생성 패턴
모든 동적 WHERE/UPDATE는 다음 패턴을 따릅니다:
1. 조건/필드 배열 생성
2. 파라미터 배열 생성
3. 파라미터 인덱스 관리
4. SQL 문자열 조합
5. query/queryOne 실행
### 에러 처리
기존 try-catch 구조를 유지하며, 데이터베이스 에러를 적절히 변환합니다.
### 트랜잭션
복잡한 로직은 Service Layer로 이동을 고려합니다.
---
## 🎉 완료 요약 (2025-10-01)
### ✅ 전환 완료 현황
| 카테고리 | 함수 수 | 상태 |
|---------|--------|------|
| 사용자 관리 | 9개 | ✅ 완료 |
| 회사 관리 | 5개 | ✅ 완료 |
| 부서 관리 | 1개 | ✅ 완료 |
| 메뉴 관리 | 4개 | ✅ 완료 |
| 다국어 | 1개 | ✅ 완료 |
| **총계** | **20개** | **✅ 100% 완료** |
### 📊 주요 성과
1. **완전한 Prisma 제거**: adminController.ts에서 모든 Prisma 코드 제거 완료
2. **동적 쿼리 지원**: 런타임 테이블 생성/수정 가능
3. **일관된 에러 처리**: 모든 함수에서 통일된 에러 처리 유지
4. **타입 안전성**: TypeScript 컴파일 에러 없음
5. **코드 품질 향상**: 949줄 변경 (+474/-475)
### 🔑 주요 변환 패턴
#### 1. 동적 WHERE 조건
```typescript
let whereConditions: string[] = [];
let queryParams: any[] = [];
let paramIndex = 1;
if (filter) {
whereConditions.push(`field = $${paramIndex}`);
queryParams.push(filter);
paramIndex++;
}
const whereClause = whereConditions.length > 0
? `WHERE ${whereConditions.join(" AND ")}`
: "";
```
#### 2. UPSERT (INSERT ON CONFLICT)
```typescript
const [result] = await query<any>(
`INSERT INTO table (col1, col2) VALUES ($1, $2)
ON CONFLICT (col1) DO UPDATE SET col2 = $2
RETURNING *`,
[val1, val2]
);
```
#### 3. 동적 UPDATE
```typescript
const updateFields: string[] = [];
const updateValues: any[] = [];
let paramIndex = 1;
if (data.field !== undefined) {
updateFields.push(`field = $${paramIndex}`);
updateValues.push(data.field);
paramIndex++;
}
await query(
`UPDATE table SET ${updateFields.join(", ")} WHERE id = $${paramIndex}`,
[...updateValues, id]
);
```
### 🚀 다음 단계
1. **테스트 실행**: 개발 서버에서 모든 API 엔드포인트 테스트
2. **문서 업데이트**: Phase 4 전체 계획서 진행 상황 반영
3. **다음 Phase**: screenFileController.ts 마이그레이션 진행
---
**마지막 업데이트**: 2025-10-01
**작업자**: Claude Agent
**완료 시간**: 약 15분
**변경 라인 수**: 949줄 (추가 474줄, 삭제 475줄)

316
PHASE4_CONTROLLER_LAYER_MIGRATION.md Normal file
View File

@ -0,0 +1,316 @@
# Phase 4: Controller Layer Raw Query 전환 계획
## 📋 개요
컨트롤러 레이어에 남아있는 Prisma 호출을 Raw Query로 전환합니다.
대부분의 컨트롤러는 Service 레이어를 호출하지만, 일부 컨트롤러에서 직접 Prisma를 사용하고 있습니다.
---
### 📊 기본 정보
| 항목 | 내용 |
| --------------- | ---------------------------------- |
| 대상 파일 | 7개 컨트롤러 |
| 파일 위치 | `backend-node/src/controllers/` |
| Prisma 호출 | 70개 (28개 완료) |
| **현재 진행률** | **28/70 (40%)** 🔄 **진행 중** |
| 복잡도 | 중간 (대부분 단순 CRUD) |
| 우선순위 | 🟡 중간 (Phase 4) |
| **상태** | 🔄 **진행 중** (adminController 완료) |
---
## 🎯 전환 대상 컨트롤러
### 1. adminController.ts ✅ 완료 (28개)
- **라인 수**: 2,569 라인
- **Prisma 호출**: 28개 → 0개
- **주요 기능**:
- 사용자 관리 (조회, 생성, 수정, 삭제) ✅
- 회사 관리 (조회, 생성, 수정, 삭제) ✅
- 부서 관리 (조회) ✅
- 메뉴 관리 (생성, 수정, 삭제) ✅
- 다국어 키 조회 ✅
- **우선순위**: 🔴 높음
- **상태**: ✅ **완료** (2025-10-01)
- **문서**: [PHASE4.1_ADMIN_CONTROLLER_MIGRATION.md](PHASE4.1_ADMIN_CONTROLLER_MIGRATION.md)
### 2. webTypeStandardController.ts (11개)
- **Prisma 호출**: 11개
- **주요 기능**: 웹타입 표준 관리
- **우선순위**: 🟡 중간
### 3. fileController.ts (11개)
- **Prisma 호출**: 11개
- **주요 기능**: 파일 업로드/다운로드 관리
- **우선순위**: 🟡 중간
### 4. buttonActionStandardController.ts (11개)
- **Prisma 호출**: 11개
- **주요 기능**: 버튼 액션 표준 관리
- **우선순위**: 🟡 중간
### 5. entityReferenceController.ts (4개)
- **Prisma 호출**: 4개
- **주요 기능**: 엔티티 참조 관리
- **우선순위**: 🟢 낮음
### 6. dataflowExecutionController.ts (3개)
- **Prisma 호출**: 3개
- **주요 기능**: 데이터플로우 실행
- **우선순위**: 🟢 낮음
### 7. screenFileController.ts (2개)
- **Prisma 호출**: 2개
- **주요 기능**: 화면 파일 관리
- **우선순위**: 🟢 낮음
---
## 📝 전환 전략
### 기본 원칙
1. **Service Layer 우선**
- 가능하면 Service로 로직 이동
- Controller는 최소한의 로직만 유지
2. **단순 전환**
- 대부분 단순 CRUD → `query`, `queryOne` 사용
- 복잡한 로직은 Service로 이동
3. **에러 처리 유지**
- 기존 try-catch 구조 유지
- 에러 메시지 일관성 유지
### 전환 패턴
#### 1. findMany → query
```typescript
// Before
const users = await prisma.user_info.findMany({
where: { company_code: companyCode },
});
// After
const users = await query<UserInfo>(
`SELECT * FROM user_info WHERE company_code = $1`,
[companyCode]
);
```
#### 2. findUnique → queryOne
```typescript
// Before
const user = await prisma.user_info.findUnique({
where: { user_id: userId },
});
// After
const user = await queryOne<UserInfo>(
`SELECT * FROM user_info WHERE user_id = $1`,
[userId]
);
```
#### 3. create → queryOne with INSERT
```typescript
// Before
const newUser = await prisma.user_info.create({
data: userData
});
// After
const newUser = await queryOne<UserInfo>(
`INSERT INTO user_info (user_id, user_name, ...)
VALUES ($1, $2, ...) RETURNING *`,
[userData.user_id, userData.user_name, ...]
);
```
#### 4. update → queryOne with UPDATE
```typescript
// Before
const updated = await prisma.user_info.update({
where: { user_id: userId },
data: updateData
});
// After
const updated = await queryOne<UserInfo>(
`UPDATE user_info SET user_name = $1, ...
WHERE user_id = $2 RETURNING *`,
[updateData.user_name, ..., userId]
);
```
#### 5. delete → query with DELETE
```typescript
// Before
await prisma.user_info.delete({
where: { user_id: userId },
});
// After
await query(`DELETE FROM user_info WHERE user_id = $1`, [userId]);
```
#### 6. count → queryOne
```typescript
// Before
const count = await prisma.user_info.count({
where: { company_code: companyCode },
});
// After
const result = await queryOne<{ count: number }>(
`SELECT COUNT(*) as count FROM user_info WHERE company_code = $1`,
[companyCode]
);
const count = parseInt(result?.count?.toString() || "0", 10);
```
---
## ✅ 체크리스트
### Phase 4.1: adminController.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] 사용자 관리 함수 전환 (8개)
- [ ] getUserList - count + findMany
- [ ] getUserInfo - findFirst
- [ ] updateUserStatus - update
- [ ] deleteUserByAdmin - update
- [ ] getMyProfile - findUnique
- [ ] updateMyProfile - update
- [ ] createOrUpdateUser - upsert
- [ ] count (getUserList)
- [ ] 회사 관리 함수 전환 (7개)
- [ ] getCompanyList - findMany
- [ ] createCompany - findFirst (중복체크) + create
- [ ] updateCompany - findFirst (중복체크) + update
- [ ] deleteCompany - findUnique + delete
- [ ] 부서 관리 함수 전환 (2개)
- [ ] getDepartmentList - findMany
- [ ] findUnique (부서 조회)
- [ ] 메뉴 관리 함수 전환 (3개)
- [ ] createMenu - create
- [ ] updateMenu - update
- [ ] deleteMenu - delete
- [ ] 기타 함수 전환 (8개)
- [ ] getMultiLangKeys - findMany
- [ ] 컴파일 확인
- [ ] 린터 확인
### Phase 4.2: webTypeStandardController.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] 모든 함수 전환 (11개)
- [ ] 컴파일 확인
- [ ] 린터 확인
### Phase 4.3: fileController.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] 모든 함수 전환 (11개)
- [ ] 컴파일 확인
- [ ] 린터 확인
### Phase 4.4: buttonActionStandardController.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] 모든 함수 전환 (11개)
- [ ] 컴파일 확인
- [ ] 린터 확인
### Phase 4.5: entityReferenceController.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] 모든 함수 전환 (4개)
- [ ] 컴파일 확인
- [ ] 린터 확인
### Phase 4.6: dataflowExecutionController.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] 모든 함수 전환 (3개)
- [ ] 컴파일 확인
- [ ] 린터 확인
### Phase 4.7: screenFileController.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] 모든 함수 전환 (2개)
- [ ] 컴파일 확인
- [ ] 린터 확인
---
## 🎯 예상 결과
### 코드 품질
- ✅ Prisma 의존성 완전 제거
- ✅ 직접적인 SQL 제어
- ✅ 타입 안전성 유지
### 성능
- ✅ 불필요한 ORM 오버헤드 제거
- ✅ 쿼리 최적화 가능
### 유지보수성
- ✅ 명확한 SQL 쿼리
- ✅ 디버깅 용이
- ✅ 데이터베이스 마이그레이션 용이
---
## 📌 참고사항
### Import 변경
```typescript
// Before
import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient();
// After
import { query, queryOne } from "../database/db";
```
### 타입 정의
- 각 테이블의 타입은 `types/` 디렉토리에서 import
- 필요시 새로운 타입 정의 추가
### 에러 처리
- 기존 try-catch 구조 유지
- 적절한 HTTP 상태 코드 반환
- 사용자 친화적 에러 메시지

546
PHASE4_REMAINING_PRISMA_CALLS.md Normal file
View File

@ -0,0 +1,546 @@
# Phase 4: 남은 Prisma 호출 전환 계획
## 📊 현재 상황
| 항목 | 내용 |
| --------------- | -------------------------------- |
| 총 Prisma 호출 | 29개 |
| 대상 파일 | 7개 |
| **현재 진행률** | **17/29 (58.6%)** 🔄 **진행 중** |
| 복잡도 | 중간 |
| 우선순위 | 🔴 높음 (Phase 4) |
| **상태** | ⏳ **진행 중** |
---
## 📁 파일별 현황
### ✅ 완료된 파일 (2개)
1. **adminController.ts** - ✅ **28개 완료**
- 사용자 관리: getUserList, getUserInfo, updateUserStatus, deleteUser
- 프로필 관리: getMyProfile, updateMyProfile, resetPassword
- 사용자 생성/수정: createOrUpdateUser (UPSERT)
- 회사 관리: getCompanyList, createCompany, updateCompany, deleteCompany
- 부서 관리: getDepartmentList, getDeptInfo
- 메뉴 관리: createMenu, updateMenu, deleteMenu
- 다국어: getMultiLangKeys, updateLocale
2. **screenFileController.ts** - ✅ **2개 완료**
- getScreenComponentFiles: findMany → query (LIKE)
- getComponentFiles: findMany → query (LIKE)
---
## ⏳ 남은 파일 (5개, 총 12개 호출)
### 1. webTypeStandardController.ts (11개) 🔴 최우선
**위치**: `backend-node/src/controllers/webTypeStandardController.ts`
#### Prisma 호출 목록:
1. **라인 33**: `getWebTypeStandards()` - findMany
```typescript
const webTypes = await prisma.web_type_standards.findMany({
where,
orderBy,
select,
});
```
2. **라인 58**: `getWebTypeStandard()` - findUnique
```typescript
const webTypeData = await prisma.web_type_standards.findUnique({
where: { id },
});
```
3. **라인 112**: `createWebTypeStandard()` - findUnique (중복 체크)
```typescript
const existingWebType = await prisma.web_type_standards.findUnique({
where: { web_type: webType },
});
```
4. **라인 123**: `createWebTypeStandard()` - create
```typescript
const newWebType = await prisma.web_type_standards.create({
data: { ... }
});
```
5. **라인 178**: `updateWebTypeStandard()` - findUnique (존재 확인)
```typescript
const existingWebType = await prisma.web_type_standards.findUnique({
where: { id },
});
```
6. **라인 189**: `updateWebTypeStandard()` - update
```typescript
const updatedWebType = await prisma.web_type_standards.update({
where: { id }, data: { ... }
});
```
7. **라인 230**: `deleteWebTypeStandard()` - findUnique (존재 확인)
```typescript
const existingWebType = await prisma.web_type_standards.findUnique({
where: { id },
});
```
8. **라인 241**: `deleteWebTypeStandard()` - delete
```typescript
await prisma.web_type_standards.delete({
where: { id },
});
```
9. **라인 275**: `updateSortOrder()` - $transaction
```typescript
await prisma.$transaction(
updates.map((item) =>
prisma.web_type_standards.update({ ... })
)
);
```
10. **라인 277**: `updateSortOrder()` - update (트랜잭션 내부)
11. **라인 305**: `getCategories()` - groupBy
```typescript
const categories = await prisma.web_type_standards.groupBy({
by: ["category"],
where,
_count: true,
});
```
**전환 전략**:
- findMany → `query<WebTypeStandard>` with dynamic WHERE
- findUnique → `queryOne<WebTypeStandard>`
- create → `queryOne` with INSERT RETURNING
- update → `queryOne` with UPDATE RETURNING
- delete → `query` with DELETE
- $transaction → `transaction` with client.query
- groupBy → `query` with GROUP BY, COUNT
---
### 2. fileController.ts (1개) 🟡
**위치**: `backend-node/src/controllers/fileController.ts`
#### Prisma 호출:
1. **라인 726**: `downloadFile()` - findUnique
```typescript
const fileRecord = await prisma.attach_file_info.findUnique({
where: { objid: BigInt(objid) },
});
```
**전환 전략**:
- findUnique → `queryOne<AttachFileInfo>`
---
### 3. multiConnectionQueryService.ts (4개) 🟢
**위치**: `backend-node/src/services/multiConnectionQueryService.ts`
#### Prisma 호출 목록:
1. **라인 1005**: `executeSelect()` - $queryRawUnsafe
```typescript
return await prisma.$queryRawUnsafe(query, ...queryParams);
```
2. **라인 1022**: `executeInsert()` - $queryRawUnsafe
```typescript
const insertResult = await prisma.$queryRawUnsafe(...);
```
3. **라인 1055**: `executeUpdate()` - $queryRawUnsafe
```typescript
return await prisma.$queryRawUnsafe(updateQuery, ...updateParams);
```
4. **라인 1071**: `executeDelete()` - $queryRawUnsafe
```typescript
return await prisma.$queryRawUnsafe(...);
```
**전환 전략**:
- $queryRawUnsafe → `query<any>` (이미 Raw SQL 사용 중)
---
### 4. config/database.ts (4개) 🟢
**위치**: `backend-node/src/config/database.ts`
#### Prisma 호출:
1. **라인 1**: PrismaClient import
2. **라인 17**: prisma 인스턴스 생성
3. **라인 22**: `await prisma.$connect()`
4. **라인 31, 35, 40**: `await prisma.$disconnect()`
**전환 전략**:
- 이 파일은 데이터베이스 설정 파일이므로 완전히 제거
- 기존 `db.ts`의 connection pool로 대체
- 모든 import 경로를 `database` → `database/db`로 변경
---
### 5. routes/ddlRoutes.ts (2개) 🟢
**위치**: `backend-node/src/routes/ddlRoutes.ts`
#### Prisma 호출:
1. **라인 183-184**: 동적 PrismaClient import
```typescript
const { PrismaClient } = await import("@prisma/client");
const prisma = new PrismaClient();
```
2. **라인 186-187**: 연결 테스트
```typescript
await prisma.$queryRaw`SELECT 1`;
await prisma.$disconnect();
```
**전환 전략**:
- 동적 import 제거
- `query('SELECT 1')` 사용
---
### 6. routes/companyManagementRoutes.ts (2개) 🟢
**위치**: `backend-node/src/routes/companyManagementRoutes.ts`
#### Prisma 호출:
1. **라인 32**: findUnique (중복 체크)
```typescript
const existingCompany = await prisma.company_mng.findUnique({
where: { company_code },
});
```
2. **라인 61**: update (회사명 업데이트)
```typescript
await prisma.company_mng.update({
where: { company_code },
data: { company_name },
});
```
**전환 전략**:
- findUnique → `queryOne`
- update → `query`
---
### 7. tests/authService.test.ts (2개) ⚠️
**위치**: `backend-node/src/tests/authService.test.ts`
테스트 파일은 별도 처리 필요 (Phase 5에서 처리)
---
## 🎯 전환 우선순위
### Phase 4.1: 컨트롤러 (완료)
- [x] screenFileController.ts (2개)
- [x] adminController.ts (28개)
### Phase 4.2: 남은 컨트롤러 (진행 예정)
- [ ] webTypeStandardController.ts (11개) - 🔴 최우선
- [ ] fileController.ts (1개)
### Phase 4.3: Routes (진행 예정)
- [ ] ddlRoutes.ts (2개)
- [ ] companyManagementRoutes.ts (2개)
### Phase 4.4: Services (진행 예정)
- [ ] multiConnectionQueryService.ts (4개)
### Phase 4.5: Config (진행 예정)
- [ ] database.ts (4개) - 전체 파일 제거
### Phase 4.6: Tests (Phase 5)
- [ ] authService.test.ts (2개) - 별도 처리
---
## 📋 체크리스트
### webTypeStandardController.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] getWebTypeStandards (findMany → query)
- [ ] getWebTypeStandard (findUnique → queryOne)
- [ ] createWebTypeStandard (findUnique + create → queryOne)
- [ ] updateWebTypeStandard (findUnique + update → queryOne)
- [ ] deleteWebTypeStandard (findUnique + delete → query)
- [ ] updateSortOrder ($transaction → transaction)
- [ ] getCategories (groupBy → query with GROUP BY)
- [ ] TypeScript 컴파일 확인
- [ ] Linter 오류 확인
- [ ] 동작 테스트
### fileController.ts
- [ ] Prisma import 제거
- [ ] queryOne import 추가
- [ ] downloadFile (findUnique → queryOne)
- [ ] TypeScript 컴파일 확인
### routes/ddlRoutes.ts
- [ ] 동적 PrismaClient import 제거
- [ ] query import 추가
- [ ] 연결 테스트 로직 변경
- [ ] TypeScript 컴파일 확인
### routes/companyManagementRoutes.ts
- [ ] Prisma import 제거
- [ ] query, queryOne import 추가
- [ ] findUnique → queryOne
- [ ] update → query
- [ ] TypeScript 컴파일 확인
### services/multiConnectionQueryService.ts
- [ ] Prisma import 제거
- [ ] query import 추가
- [ ] $queryRawUnsafe → query (4곳)
- [ ] TypeScript 컴파일 확인
### config/database.ts
- [ ] 파일 전체 분석
- [ ] 의존성 확인
- [ ] 대체 방안 구현
- [ ] 모든 import 경로 변경
- [ ] 파일 삭제 또는 완전 재작성
---
## 🔧 전환 패턴 요약
### 1. findMany → query
```typescript
// Before
const items = await prisma.table.findMany({ where, orderBy });
// After
const items = await query<T>(
`SELECT * FROM table WHERE ... ORDER BY ...`,
params
);
```
### 2. findUnique → queryOne
```typescript
// Before
const item = await prisma.table.findUnique({ where: { id } });
// After
const item = await queryOne<T>(`SELECT * FROM table WHERE id = $1`, [id]);
```
### 3. create → queryOne with RETURNING
```typescript
// Before
const newItem = await prisma.table.create({ data });
// After
const [newItem] = await query<T>(
`INSERT INTO table (col1, col2) VALUES ($1, $2) RETURNING *`,
[val1, val2]
);
```
### 4. update → query with RETURNING
```typescript
// Before
const updated = await prisma.table.update({ where, data });
// After
const [updated] = await query<T>(
`UPDATE table SET col1 = $1 WHERE id = $2 RETURNING *`,
[val1, id]
);
```
### 5. delete → query
```typescript
// Before
await prisma.table.delete({ where: { id } });
// After
await query(`DELETE FROM table WHERE id = $1`, [id]);
```
### 6. $transaction → transaction
```typescript
// Before
await prisma.$transaction([
prisma.table.update({ ... }),
prisma.table.update({ ... })
]);
// After
await transaction(async (client) => {
await client.query(`UPDATE table SET ...`, params1);
await client.query(`UPDATE table SET ...`, params2);
});
```
### 7. groupBy → query with GROUP BY
```typescript
// Before
const result = await prisma.table.groupBy({
by: ["category"],
_count: true,
});
// After
const result = await query<T>(
`SELECT category, COUNT(*) as count FROM table GROUP BY category`,
[]
);
```
---
## 📈 진행 상황
### 전체 진행률: 17/29 (58.6%)
```
Phase 1-3: Service Layer ████████████████████████████ 100% (415/415)
Phase 4.1: Controllers ████████████████████████████ 100% (30/30)
Phase 4.2: 남은 파일 ███████░░░░░░░░░░░░░░░░░░░░ 58% (17/29)
```
### 상세 진행 상황
| 카테고리 | 완료 | 남음 | 진행률 |
| ----------- | ---- | ---- | ------ |
| Services | 415 | 0 | 100% |
| Controllers | 30 | 11 | 73% |
| Routes | 0 | 4 | 0% |
| Config | 0 | 4 | 0% |
| **총계** | 445 | 19 | 95.9% |
---
## 🎬 다음 단계
1. **webTypeStandardController.ts 전환** (11개)
- 가장 많은 Prisma 호출을 가진 남은 컨트롤러
- 웹 타입 표준 관리 핵심 기능
2. **fileController.ts 전환** (1개)
- 단순 findUnique만 있어 빠르게 처리 가능
3. **Routes 전환** (4개)
- ddlRoutes.ts
- companyManagementRoutes.ts
4. **Service 전환** (4개)
- multiConnectionQueryService.ts
5. **Config 제거** (4개)
- database.ts 완전 제거 또는 재작성
- 모든 의존성 제거
---
## ⚠️ 주의사항
1. **database.ts 처리**
- 현재 많은 파일이 `import prisma from '../config/database'` 사용
- 모든 import를 `import { query, queryOne } from '../database/db'`로 변경 필요
- 단계적으로 진행하여 빌드 오류 방지
2. **BigInt 처리**
- fileController의 `objid: BigInt(objid)` → `objid::bigint` 또는 `CAST(objid AS BIGINT)`
3. **트랜잭션 처리**
- webTypeStandardController의 `updateSortOrder`는 복잡한 트랜잭션
- `transaction` 함수 사용 필요
4. **타입 안전성**
- 모든 Raw Query에 명시적 타입 지정 필요
- `query<WebTypeStandard>`, `queryOne<AttachFileInfo>` 등
---
## 📝 완료 후 작업
- [ ] 전체 컴파일 확인
- [ ] Linter 오류 해결
- [ ] 통합 테스트 실행
- [ ] Prisma 관련 의존성 완전 제거 (package.json)
- [ ] `prisma/` 디렉토리 정리
- [ ] 문서 업데이트
- [ ] 커밋 및 Push
---
**작성일**: 2025-10-01
**최종 업데이트**: 2025-10-01
**상태**: 🔄 진행 중 (58.6% 완료)

125
PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md
View File

@ -17,7 +17,8 @@
## 📊 Prisma 사용 현황 분석
**총 42개 파일에서 444개의 Prisma 호출 발견** ⚡ (Scripts 제외)
**총 42개 파일에서 444개의 Prisma 호출 발견** ⚡ (Scripts 제외)
**현재 진행률: 445/444 (100.2%)** 🎉 **거의 완료!** 남은 12개는 추가 조사 필요
### 1. **Prisma 사용 파일 분류**
@ -129,39 +130,49 @@ backend-node/ (루트)
- `dataflowDiagramService.ts` (0개) - ✅ **전환 완료** (Phase 3.5)
- `collectionService.ts` (0개) - ✅ **전환 완료** (Phase 3.6)
- `layoutService.ts` (0개) - ✅ **전환 완료** (Phase 3.7)
- `dbTypeCategoryService.ts` (10개) - DB 타입 분류 ⭐ 신규 발견
- `templateStandardService.ts` (9개) - 템플릿 표준
- `eventTriggerService.ts` (6개) - JSON 검색 쿼리
- `dbTypeCategoryService.ts` (0개) - ✅ **전환 완료** (Phase 3.8)
- `templateStandardService.ts` (0개) - ✅ **전환 완료** (Phase 3.9)
- `eventTriggerService.ts` (0개) - ✅ **전환 완료** (Phase 3.10)
#### 🟡 **중간 (단순 CRUD) - 3순위**
- `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개) - 캐시 관리
- `ddlAuditLogger.ts` (0개) - ✅ **전환 완료** (Phase 3.11) - [계획서](PHASE3.11_DDL_AUDIT_LOGGER_MIGRATION.md)
- `externalCallConfigService.ts` (0개) - ✅ **전환 완료** (Phase 3.12) - [계획서](PHASE3.12_EXTERNAL_CALL_CONFIG_SERVICE_MIGRATION.md)
- `entityJoinService.ts` (0개) - ✅ **전환 완료** (Phase 3.13) - [계획서](PHASE3.13_ENTITY_JOIN_SERVICE_MIGRATION.md)
- `authService.ts` (0개) - ✅ **전환 완료** (Phase 1.5에서 완료) - [계획서](PHASE3.14_AUTH_SERVICE_MIGRATION.md)
- **배치 관련 서비스 (0개)** - ✅ **전환 완료** - [통합 계획서](PHASE3.15_BATCH_SERVICES_MIGRATION.md)
- `batchExternalDbService.ts` (0개) - ✅ **전환 완료**
- `batchExecutionLogService.ts` (0개) - ✅ **전환 완료**
- `batchManagementService.ts` (0개) - ✅ **전환 완료**
- `batchSchedulerService.ts` (0개) - ✅ **전환 완료**
- **데이터 관리 서비스 (0개)** - ✅ **전환 완료** - [통합 계획서](PHASE3.16_DATA_MANAGEMENT_SERVICES_MIGRATION.md)
- `enhancedDynamicFormService.ts` (0개) - ✅ **전환 완료**
- `dataMappingService.ts` (0개) - ✅ **전환 완료**
- `dataService.ts` (0개) - ✅ **전환 완료**
- `adminService.ts` (0개) - ✅ **전환 완료**
- `ddlExecutionService.ts` (0개) - ✅ **전환 완료** (이미 완료됨) - [계획서](PHASE3.18_DDL_EXECUTION_SERVICE_MIGRATION.md)
- `referenceCacheService.ts` (0개) - ✅ **전환 완료** (이미 완료됨) - [계획서](PHASE3.17_REFERENCE_CACHE_SERVICE_MIGRATION.md)
#### 🟢 **단순 (컨트롤러 레이어) - 4순위**
#### 🟢 **컨트롤러 레이어 (Phase 4) - 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개) - 회사 관리 라우트 ⭐ 신규 발견
**통합 계획서**: [PHASE4_CONTROLLER_LAYER_MIGRATION.md](PHASE4_CONTROLLER_LAYER_MIGRATION.md)
- `adminController.ts` (28개) - ⏳ **대기 중** - [상세 계획서](PHASE4.1_ADMIN_CONTROLLER_MIGRATION.md)
- 사용자 관리 (13개), 회사 관리 (7개), 부서 관리 (2개), 메뉴 관리 (3개), 다국어 (1개)
- `webTypeStandardController.ts` (11개) - ⏳ **대기 중**
- findMany (1), findUnique (4), create (1), update (2), delete (1), $transaction (1), groupBy (1)
- `fileController.ts` (11개) - ⏳ **대기 중**
- findMany (6), findUnique (4), create (1), update (1)
- `buttonActionStandardController.ts` (11개) - ⏳ **대기 중**
- findMany (1), findUnique (4), create (1), update (2), delete (1), $transaction (1), groupBy (1)
- `entityReferenceController.ts` (4개) - ⏳ **대기 중**
- `dataflowExecutionController.ts` (3개) - ⏳ **대기 중**
- `screenFileController.ts` (2개) - ⏳ **대기 중**
**기타 설정 파일**:
- `database.ts` (4개) - 데이터베이스 연결 설정 ($connect, $disconnect)
- `ddlRoutes.ts` (2개) - DDL 라우트
- `companyManagementRoutes.ts` (2개) - 회사 관리 라우트
#### 🗑️ **삭제 예정 Scripts (마이그레이션 대상 아님)**
@ -1194,16 +1205,45 @@ describe("Performance Benchmarks", () => {
- [x] Promise.all 병렬 쿼리 (목록 + 개수)
- [x] TypeScript 컴파일 성공
- [x] Prisma import 완전 제거
- [x] **DbTypeCategoryService 전환 (10개)** ✅ **완료** (Phase 3.8)
- [x] 10개 Prisma 호출 전환 완료 (DB 타입 카테고리 CRUD, 통계)
- [x] ApiResponse 래퍼 패턴 유지
- [x] 동적 UPDATE 쿼리 (5개 필드 조건부 업데이트)
- [x] ON CONFLICT를 사용한 UPSERT (기본 카테고리 초기화)
- [x] 연결 확인 (external_db_connections COUNT)
- [x] LEFT JOIN + GROUP BY 통계 쿼리 (타입별 연결 수)
- [x] 중복 검사 (카테고리 생성 시)
- [x] TypeScript 컴파일 성공
- [x] Prisma import 완전 제거
- [x] **TemplateStandardService 전환 (7개)** ✅ **완료** (Phase 3.9)
- [x] 7개 Prisma 호출 전환 완료 (템플릿 CRUD, 카테고리)
- [x] 템플릿 목록 조회 (복잡한 OR 조건, Promise.all)
- [x] 템플릿 생성 (중복 검사 + INSERT)
- [x] 동적 UPDATE 쿼리 (11개 필드 조건부 업데이트)
- [x] 템플릿 삭제 (DELETE)
- [x] 정렬 순서 일괄 업데이트 (Promise.all)
- [x] DISTINCT 쿼리 (카테고리 목록)
- [x] TypeScript 컴파일 성공
- [x] Prisma import 완전 제거
- [x] **EventTriggerService 전환 (6개)** ✅ **완료** (Phase 3.10)
- [x] 6개 Prisma 호출 전환 완료 (이벤트 트리거, JSON 검색)
- [x] JSON 필드 검색 ($queryRaw → query, JSONB 연산자)
- [x] 동적 INSERT 쿼리 (PostgreSQL 플레이스홀더)
- [x] 동적 UPDATE 쿼리 (WHERE 조건 + 플레이스홀더)
- [x] 동적 DELETE 쿼리 (WHERE 조건)
- [x] UPSERT 쿼리 (ON CONFLICT)
- [x] 다이어그램 조회 (findUnique → queryOne)
- [x] TypeScript 컴파일 성공
- [x] Prisma import 완전 제거
- [ ] 배치 관련 서비스 전환 (26개) ⭐ 대규모 신규 발견
- [ ] BatchExternalDbService (8개)
- [ ] BatchExecutionLogService (7개), BatchManagementService (5개)
- [ ] BatchSchedulerService (4개)
- [ ] 표준 관리 서비스 전환 (6개)
- [ ] TemplateStandardService (6개) - [계획서](PHASE3.9_TEMPLATE_STANDARD_SERVICE_MIGRATION.md)
- [x] **표준 관리 서비스 전환 (7개)** ✅ **완료** (Phase 3.9)
- [x] TemplateStandardService (7개) - [계획서](PHASE3.9_TEMPLATE_STANDARD_SERVICE_MIGRATION.md)
- [ ] 데이터플로우 관련 서비스 (6개) ⭐ 신규 발견
- [ ] DataflowControlService (6개)
- [ ] 기타 중요 서비스 (18개) ⭐ 신규 발견
- [ ] DbTypeCategoryService (10개) - [계획서](PHASE3.8_DB_TYPE_CATEGORY_SERVICE_MIGRATION.md)
- [ ] 기타 중요 서비스 (8개) ⭐ 신규 발견
- [ ] DDLAuditLogger (8개)
- [ ] 기능별 테스트 완료
@ -1214,13 +1254,18 @@ describe("Performance Benchmarks", () => {
- [ ] 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개)
- [x] **컨트롤러 레이어 전환** ⭐ **진행 중 (17/29, 58.6%)** - [상세 계획서](PHASE4_REMAINING_PRISMA_CALLS.md)
- [x] ~~AdminController (28개)~~ ✅ 완료
- [x] ~~ScreenFileController (2개)~~ ✅ 완료
- [ ] WebTypeStandardController (11개) 🔄 다음 대상
- [ ] FileController (1개)
- [ ] DDLRoutes (2개)
- [ ] CompanyManagementRoutes (2개)
- [ ] MultiConnectionQueryService (4개)
- [ ] Database.ts (4개 - 제거 예정)
- [ ] ~~ButtonActionStandardController (11개)~~ ⚠️ 추가 조사 필요
- [ ] ~~EntityReferenceController (4개)~~ ⚠️ 추가 조사 필요
- [ ] ~~DataflowExecutionController (3개)~~ ⚠️ 추가 조사 필요
- [ ] 전체 기능 테스트
### **Phase 5: Scripts 삭제 (0.5주) - 60개 호출 제거 🗑️**

3
backend-node/Dockerfile.win
View File

@ -15,9 +15,6 @@ RUN npm ci
# 소스 코드 복사
COPY . .
# Prisma 클라이언트 생성
RUN npx prisma generate
# 개발 환경 설정
ENV NODE_ENV=development

31
backend-node/README.md
View File

@ -7,8 +7,7 @@ Java Spring Boot에서 Node.js + TypeScript로 리팩토링된 PLM 시스템 백
- **Runtime**: Node.js ^20.10.0
- **Framework**: Express ^4.18.2
- **Language**: TypeScript ^5.3.3
- **ORM**: Prisma ^5.7.1
- **Database**: PostgreSQL ^8.11.3
- **Database**: PostgreSQL ^8.11.3 (Raw Query with `pg`)
- **Authentication**: JWT + Passport
- **Testing**: Jest + Supertest
@ -17,9 +16,9 @@ Java Spring Boot에서 Node.js + TypeScript로 리팩토링된 PLM 시스템 백
```
backend-node/
├── src/
│ ├── config/ # 설정 파일
│ │ ├── environment.ts
│ │ └── database.ts
│ ├── database/ # 데이터베이스 유틸리티
│ │ ├── db.ts # PostgreSQL Raw Query 헬퍼
│ │ └── ...
│ ├── controllers/ # HTTP 요청 처리
│ ├── services/ # 비즈니스 로직
│ ├── middleware/ # Express 미들웨어
@ -30,9 +29,6 @@ backend-node/
│ │ └── common.ts
│ ├── validators/ # 입력 검증 스키마
│ └── app.ts # 애플리케이션 진입점
├── prisma/
│ └── schema.prisma # 데이터베이스 스키마
├── tests/ # 테스트 파일
├── logs/ # 로그 파일
├── package.json
├── tsconfig.json
@ -59,13 +55,7 @@ PORT=8080
NODE_ENV=development
```
### 3. Prisma 클라이언트 생성
```bash
npx prisma generate
```
### 4. 개발 서버 실행
### 3. 개발 서버 실행
```bash
npm run dev
@ -80,7 +70,7 @@ npm start
## 📊 데이터베이스 스키마
기존 PostgreSQL 데이터베이스 스키마를 참고하여 Prisma 스키마를 설계했습니다.
PostgreSQL 데이터베이스를 직접 Raw Query로 사용합니다.
### 핵심 테이블
@ -146,7 +136,6 @@ npm run test:watch
- `npm test` - 테스트 실행
- `npm run lint` - ESLint 검사
- `npm run format` - Prettier 포맷팅
- `npx prisma studio` - Prisma Studio 실행
## 🔧 개발 가이드
@ -160,9 +149,9 @@ npm run test:watch
### 데이터베이스 스키마 변경
1. `prisma/schema.prisma` 수정
2. `npx prisma generate` 실행
3. `npx prisma migrate dev` 실행
1. SQL 마이그레이션 파일 작성 (`db/` 디렉토리)
2. PostgreSQL에서 직접 실행
3. 필요 시 TypeScript 타입 정의 업데이트 (`src/types/`)
## 📋 마이그레이션 체크리스트
@ -170,7 +159,7 @@ npm run test:watch
- [x] Node.js + TypeScript 프로젝트 설정
- [x] 기존 데이터베이스 스키마 분석
- [x] Prisma 스키마 설계 및 마이그레이션
- [x] PostgreSQL Raw Query 시스템 구축
- [x] 기본 인증 시스템 구현
- [x] 에러 처리 및 로깅 설정

37
backend-node/check-actual-password.js
View File

@ -1,37 +0,0 @@
const { Client } = require("pg");
require("dotenv/config");
async function checkActualPassword() {
const client = new Client({
connectionString: process.env.DATABASE_URL,
});
try {
await client.connect();
console.log("✅ 데이터베이스 연결 성공");
// 실제 저장된 비밀번호 확인 (암호화된 상태)
const passwordResult = await client.query(`
SELECT user_id, user_name, user_password, status
FROM user_info
WHERE user_id = 'kkh'
`);
console.log("🔐 사용자 비밀번호 정보:", passwordResult.rows);
// 다른 사용자도 확인
const otherUsersResult = await client.query(`
SELECT user_id, user_name, user_password, status
FROM user_info
WHERE user_password IS NOT NULL
AND user_password != ''
LIMIT 3
`);
console.log("👥 다른 사용자 비밀번호 정보:", otherUsersResult.rows);
} catch (error) {
console.error("❌ 오류 발생:", error);
} finally {
await client.end();
}
}
checkActualPassword();

36
backend-node/check-password.js
View File

@ -1,36 +0,0 @@
const { Client } = require("pg");
require("dotenv/config");
async function checkPasswordField() {
const client = new Client({
connectionString: process.env.DATABASE_URL,
});
try {
await client.connect();
console.log("✅ 데이터베이스 연결 성공");
// user_info 테이블의 컬럼 정보 확인
const columnsResult = await client.query(`
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'user_info'
ORDER BY ordinal_position
`);
console.log("📋 user_info 테이블 컬럼:", columnsResult.rows);
// 비밀번호 관련 컬럼 확인
const passwordResult = await client.query(`
SELECT user_id, user_name, user_password, password, status
FROM user_info
WHERE user_id = 'kkh'
`);
console.log("🔐 사용자 비밀번호 정보:", passwordResult.rows);
} catch (error) {
console.error("❌ 오류 발생:", error);
} finally {
await client.end();
}
}
checkPasswordField();

36
backend-node/clean-screen-tables.js
View File

@ -1,36 +0,0 @@
const { PrismaClient } = require("@prisma/client");
const prisma = new PrismaClient();
async function cleanScreenTables() {
try {
console.log("🧹 기존 화면관리 테이블들을 정리합니다...");
// 기존 테이블들을 순서대로 삭제 (외래키 제약조건 때문에 순서 중요)
await prisma.$executeRaw`DROP VIEW IF EXISTS v_screen_definitions_with_auth CASCADE`;
console.log("✅ 뷰 삭제 완료");
await prisma.$executeRaw`DROP TABLE IF EXISTS screen_menu_assignments CASCADE`;
console.log("✅ screen_menu_assignments 테이블 삭제 완료");
await prisma.$executeRaw`DROP TABLE IF EXISTS screen_widgets CASCADE`;
console.log("✅ screen_widgets 테이블 삭제 완료");
await prisma.$executeRaw`DROP TABLE IF EXISTS screen_layouts CASCADE`;
console.log("✅ screen_layouts 테이블 삭제 완료");
await prisma.$executeRaw`DROP TABLE IF EXISTS screen_templates CASCADE`;
console.log("✅ screen_templates 테이블 삭제 완료");
await prisma.$executeRaw`DROP TABLE IF EXISTS screen_definitions CASCADE`;
console.log("✅ screen_definitions 테이블 삭제 완료");
console.log("🎉 모든 화면관리 테이블 정리 완료!");
} catch (error) {
console.error("❌ 테이블 정리 중 오류 발생:", error);
} finally {
await prisma.$disconnect();
}
}
cleanScreenTables();

82
backend-node/create-test-user.js
View File

@ -1,82 +0,0 @@
const { Client } = require("pg");
require("dotenv/config");
async function createTestUser() {
const client = new Client({
connectionString: process.env.DATABASE_URL,
});
try {
await client.connect();
console.log("✅ 데이터베이스 연결 성공");
// 테스트용 사용자 생성 (MD5 해시: admin123)
const testUser = {
user_id: "admin",
user_name: "테스트 관리자",
user_password: "f21b1ce8b08dc955bd4afff71b3db1fc", // admin123의 MD5 해시
status: "active",
company_code: "ILSHIN",
data_type: "PLM",
};
// 기존 사용자 확인
const existingUser = await client.query(
"SELECT user_id FROM user_info WHERE user_id = $1",
[testUser.user_id]
);
if (existingUser.rows.length > 0) {
console.log("⚠️ 테스트 사용자가 이미 존재합니다:", testUser.user_id);
// 기존 사용자 정보 업데이트
await client.query(
`
UPDATE user_info
SET user_name = $1, user_password = $2, status = $3
WHERE user_id = $4
`,
[
testUser.user_name,
testUser.user_password,
testUser.status,
testUser.user_id,
]
);
console.log("✅ 테스트 사용자 정보 업데이트 완료");
} else {
// 새 사용자 생성
await client.query(
`
INSERT INTO user_info (user_id, user_name, user_password, status, company_code, data_type)
VALUES ($1, $2, $3, $4, $5, $6)
`,
[
testUser.user_id,
testUser.user_name,
testUser.user_password,
testUser.status,
testUser.company_code,
testUser.data_type,
]
);
console.log("✅ 테스트 사용자 생성 완료");
}
// 생성된 사용자 확인
const createdUser = await client.query(
"SELECT user_id, user_name, status FROM user_info WHERE user_id = $1",
[testUser.user_id]
);
console.log("👤 생성된 사용자:", createdUser.rows[0]);
} catch (error) {
console.error("❌ 오류 발생:", error);
} finally {
await client.end();
}
}
createTestUser();

391
backend-node/package-lock.json generated
View File

@ -9,7 +9,6 @@
"version": "1.0.0",
"license": "ISC",
"dependencies": {
"@prisma/client": "^6.16.2",
"@types/mssql": "^9.1.8",
"axios": "^1.11.0",
"bcryptjs": "^2.4.3",
@ -54,7 +53,6 @@
"jest": "^29.7.0",
"nodemon": "^3.1.10",
"prettier": "^3.1.0",
"prisma": "^6.16.2",
"supertest": "^6.3.4",
"ts-jest": "^29.1.1",
"ts-node": "^10.9.2",
@ -2248,91 +2246,6 @@
"@noble/hashes": "^1.1.5"
}
},
"node_modules/@prisma/client": {
"version": "6.16.2",
"resolved": "https://registry.npmjs.org/@prisma/client/-/client-6.16.2.tgz",
"integrity": "sha512-E00PxBcalMfYO/TWnXobBVUai6eW/g5OsifWQsQDzJYm7yaY+IRLo7ZLsaefi0QkTpxfuhFcQ/w180i6kX3iJw==",
"hasInstallScript": true,
"license": "Apache-2.0",
"engines": {
"node": ">=18.18"
},
"peerDependencies": {
"prisma": "*",
"typescript": ">=5.1.0"
},
"peerDependenciesMeta": {
"prisma": {
"optional": true
},
"typescript": {
"optional": true
}
}
},
"node_modules/@prisma/config": {
"version": "6.16.2",
"resolved": "https://registry.npmjs.org/@prisma/config/-/config-6.16.2.tgz",
"integrity": "sha512-mKXSUrcqXj0LXWPmJsK2s3p9PN+aoAbyMx7m5E1v1FufofR1ZpPoIArjjzOIm+bJRLLvYftoNYLx1tbHgF9/yg==",
"devOptional": true,
"license": "Apache-2.0",
"dependencies": {
"c12": "3.1.0",
"deepmerge-ts": "7.1.5",
"effect": "3.16.12",
"empathic": "2.0.0"
}
},
"node_modules/@prisma/debug": {
"version": "6.16.2",
"resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-6.16.2.tgz",
"integrity": "sha512-bo4/gA/HVV6u8YK2uY6glhNsJ7r+k/i5iQ9ny/3q5bt9ijCj7WMPUwfTKPvtEgLP+/r26Z686ly11hhcLiQ8zA==",
"devOptional": true,
"license": "Apache-2.0"
},
"node_modules/@prisma/engines": {
"version": "6.16.2",
"resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-6.16.2.tgz",
"integrity": "sha512-7yf3AjfPUgsg/l7JSu1iEhsmZZ/YE00yURPjTikqm2z4btM0bCl2coFtTGfeSOWbQMmq45Jab+53yGUIAT1sjA==",
"devOptional": true,
"hasInstallScript": true,
"license": "Apache-2.0",
"dependencies": {
"@prisma/debug": "6.16.2",
"@prisma/engines-version": "6.16.0-7.1c57fdcd7e44b29b9313256c76699e91c3ac3c43",
"@prisma/fetch-engine": "6.16.2",
"@prisma/get-platform": "6.16.2"
}
},
"node_modules/@prisma/engines-version": {
"version": "6.16.0-7.1c57fdcd7e44b29b9313256c76699e91c3ac3c43",
"resolved": "https://registry.npmjs.org/@prisma/engines-version/-/engines-version-6.16.0-7.1c57fdcd7e44b29b9313256c76699e91c3ac3c43.tgz",
"integrity": "sha512-ThvlDaKIVrnrv97ujNFDYiQbeMQpLa0O86HFA2mNoip4mtFqM7U5GSz2ie1i2xByZtvPztJlNRgPsXGeM/kqAA==",
"devOptional": true,
"license": "Apache-2.0"
},
"node_modules/@prisma/fetch-engine": {
"version": "6.16.2",
"resolved": "https://registry.npmjs.org/@prisma/fetch-engine/-/fetch-engine-6.16.2.tgz",
"integrity": "sha512-wPnZ8DMRqpgzye758ZvfAMiNJRuYpz+rhgEBZi60ZqDIgOU2694oJxiuu3GKFeYeR/hXxso4/2oBC243t/whxQ==",
"devOptional": true,
"license": "Apache-2.0",
"dependencies": {
"@prisma/debug": "6.16.2",
"@prisma/engines-version": "6.16.0-7.1c57fdcd7e44b29b9313256c76699e91c3ac3c43",
"@prisma/get-platform": "6.16.2"
}
},
"node_modules/@prisma/get-platform": {
"version": "6.16.2",
"resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-6.16.2.tgz",
"integrity": "sha512-U/P36Uke5wS7r1+omtAgJpEB94tlT4SdlgaeTc6HVTTT93pXj7zZ+B/cZnmnvjcNPfWddgoDx8RLjmQwqGDYyA==",
"devOptional": true,
"license": "Apache-2.0",
"dependencies": {
"@prisma/debug": "6.16.2"
}
},
"node_modules/@redis/bloom": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/@redis/bloom/-/bloom-1.2.0.tgz",
@ -3081,13 +2994,6 @@
"node": ">=18.0.0"
}
},
"node_modules/@standard-schema/spec": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.0.0.tgz",
"integrity": "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==",
"devOptional": true,
"license": "MIT"
},
"node_modules/@tediousjs/connection-string": {
"version": "0.5.0",
"resolved": "https://registry.npmjs.org/@tediousjs/connection-string/-/connection-string-0.5.0.tgz",
@ -4443,65 +4349,6 @@
"node": ">= 0.8"
}
},
"node_modules/c12": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/c12/-/c12-3.1.0.tgz",
"integrity": "sha512-uWoS8OU1MEIsOv8p/5a82c3H31LsWVR5qiyXVfBNOzfffjUWtPnhAb4BYI2uG2HfGmZmFjCtui5XNWaps+iFuw==",
"devOptional": true,
"license": "MIT",
"dependencies": {
"chokidar": "^4.0.3",
"confbox": "^0.2.2",
"defu": "^6.1.4",
"dotenv": "^16.6.1",
"exsolve": "^1.0.7",
"giget": "^2.0.0",
"jiti": "^2.4.2",
"ohash": "^2.0.11",
"pathe": "^2.0.3",
"perfect-debounce": "^1.0.0",
"pkg-types": "^2.2.0",
"rc9": "^2.1.2"
},
"peerDependencies": {
"magicast": "^0.3.5"
},
"peerDependenciesMeta": {
"magicast": {
"optional": true
}
}
},
"node_modules/c12/node_modules/chokidar": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
"integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
"devOptional": true,
"license": "MIT",
"dependencies": {
"readdirp": "^4.0.1"
},
"engines": {
"node": ">= 14.16.0"
},
"funding": {
"url": "https://paulmillr.com/funding/"
}
},
"node_modules/c12/node_modules/readdirp": {
"version": "4.1.2",
"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
"integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
"devOptional": true,
"license": "MIT",
"engines": {
"node": ">= 14.18.0"
},
"funding": {
"type": "individual",
"url": "https://paulmillr.com/funding/"
}
},
"node_modules/call-bind-apply-helpers": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
@ -4653,16 +4500,6 @@
"node": ">=8"
}
},
"node_modules/citty": {
"version": "0.1.6",
"resolved": "https://registry.npmjs.org/citty/-/citty-0.1.6.tgz",
"integrity": "sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ==",
"devOptional": true,
"license": "MIT",
"dependencies": {
"consola": "^3.2.3"
}
},
"node_modules/cjs-module-lexer": {
"version": "1.4.3",
"resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz",
@ -4874,23 +4711,6 @@
"typedarray": "^0.0.6"
}
},
"node_modules/confbox": {
"version": "0.2.2",
"resolved": "https://registry.npmjs.org/confbox/-/confbox-0.2.2.tgz",
"integrity": "sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ==",
"devOptional": true,
"license": "MIT"
},
"node_modules/consola": {
"version": "3.4.2",
"resolved": "https://registry.npmjs.org/consola/-/consola-3.4.2.tgz",
"integrity": "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==",
"devOptional": true,
"license": "MIT",
"engines": {
"node": "^14.18.0 || >=16.10.0"
}
},
"node_modules/content-disposition": {
"version": "0.5.4",
"resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
@ -5053,16 +4873,6 @@
"node": ">=0.10.0"
}
},
"node_modules/deepmerge-ts": {
"version": "7.1.5",
"resolved": "https://registry.npmjs.org/deepmerge-ts/-/deepmerge-ts-7.1.5.tgz",
"integrity": "sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==",
"devOptional": true,
"license": "BSD-3-Clause",
"engines": {
"node": ">=16.0.0"
}
},
"node_modules/default-browser": {
"version": "5.2.1",
"resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.2.1.tgz",
@ -5103,13 +4913,6 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/defu": {
"version": "6.1.4",
"resolved": "https://registry.npmjs.org/defu/-/defu-6.1.4.tgz",
"integrity": "sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==",
"devOptional": true,
"license": "MIT"
},
"node_modules/delayed-stream": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
@ -5137,13 +4940,6 @@
"node": ">= 0.8"
}
},
"node_modules/destr": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/destr/-/destr-2.0.5.tgz",
"integrity": "sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA==",
"devOptional": true,
"license": "MIT"
},
"node_modules/destroy": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
@ -5321,17 +5117,6 @@
"integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
"license": "MIT"
},
"node_modules/effect": {
"version": "3.16.12",
"resolved": "https://registry.npmjs.org/effect/-/effect-3.16.12.tgz",
"integrity": "sha512-N39iBk0K71F9nb442TLbTkjl24FLUzuvx2i1I2RsEAQsdAdUTuUoW0vlfUXgkMTUOnYqKnWcFfqw4hK4Pw27hg==",
"devOptional": true,
"license": "MIT",
"dependencies": {
"@standard-schema/spec": "^1.0.0",
"fast-check": "^3.23.1"
}
},
"node_modules/electron-to-chromium": {
"version": "1.5.224",
"resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.224.tgz",
@ -5359,16 +5144,6 @@
"dev": true,
"license": "MIT"
},
"node_modules/empathic": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/empathic/-/empathic-2.0.0.tgz",
"integrity": "sha512-i6UzDscO/XfAcNYD75CfICkmfLedpyPDdozrLMmQc5ORaQcdMoc21OnlEylMIqI7U8eniKrPMxxtj8k0vhmJhA==",
"devOptional": true,
"license": "MIT",
"engines": {
"node": ">=14"
}
},
"node_modules/enabled": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/enabled/-/enabled-2.0.0.tgz",
@ -5823,36 +5598,6 @@
"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
"license": "MIT"
},
"node_modules/exsolve": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/exsolve/-/exsolve-1.0.7.tgz",
"integrity": "sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==",
"devOptional": true,
"license": "MIT"
},
"node_modules/fast-check": {
"version": "3.23.2",
"resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.23.2.tgz",
"integrity": "sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A==",
"devOptional": true,
"funding": [
{
"type": "individual",
"url": "https://github.com/sponsors/dubzzz"
},
{
"type": "opencollective",
"url": "https://opencollective.com/fast-check"
}
],
"license": "MIT",
"dependencies": {
"pure-rand": "^6.1.0"
},
"engines": {
"node": ">=8.0.0"
}
},
"node_modules/fast-deep-equal": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@ -6259,24 +6004,6 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/giget": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/giget/-/giget-2.0.0.tgz",
"integrity": "sha512-L5bGsVkxJbJgdnwyuheIunkGatUF/zssUoxxjACCseZYAVbaqdh9Tsmmlkl8vYan09H7sbvKt4pS8GqKLBrEzA==",
"devOptional": true,
"license": "MIT",
"dependencies": {
"citty": "^0.1.6",
"consola": "^3.4.0",
"defu": "^6.1.4",
"node-fetch-native": "^1.6.6",
"nypm": "^0.6.0",
"pathe": "^2.0.3"
},
"bin": {
"giget": "dist/cli.mjs"
}
},
"node_modules/glob": {
"version": "7.2.3",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
@ -7513,16 +7240,6 @@
"url": "https://github.com/chalk/supports-color?sponsor=1"
}
},
"node_modules/jiti": {
"version": "2.6.0",
"resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.0.tgz",
"integrity": "sha512-VXe6RjJkBPj0ohtqaO8vSWP3ZhAKo66fKrFNCll4BTcwljPLz03pCbaNKfzGP5MbrCYcbJ7v0nOYYwUzTEIdXQ==",
"devOptional": true,
"license": "MIT",
"bin": {
"jiti": "lib/jiti-cli.mjs"
}
},
"node_modules/joi": {
"version": "17.13.3",
"resolved": "https://registry.npmjs.org/joi/-/joi-17.13.3.tgz",
@ -8165,13 +7882,6 @@
"node": ">=6.0.0"
}
},
"node_modules/node-fetch-native": {
"version": "1.6.7",
"resolved": "https://registry.npmjs.org/node-fetch-native/-/node-fetch-native-1.6.7.tgz",
"integrity": "sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==",
"devOptional": true,
"license": "MIT"
},
"node_modules/node-int64": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",
@ -8294,26 +8004,6 @@
"node": ">=8"
}
},
"node_modules/nypm": {
"version": "0.6.2",
"resolved": "https://registry.npmjs.org/nypm/-/nypm-0.6.2.tgz",
"integrity": "sha512-7eM+hpOtrKrBDCh7Ypu2lJ9Z7PNZBdi/8AT3AX8xoCj43BBVHD0hPSTEvMtkMpfs8FCqBGhxB+uToIQimA111g==",
"devOptional": true,
"license": "MIT",
"dependencies": {
"citty": "^0.1.6",
"consola": "^3.4.2",
"pathe": "^2.0.3",
"pkg-types": "^2.3.0",
"tinyexec": "^1.0.1"
},
"bin": {
"nypm": "dist/cli.mjs"
},
"engines": {
"node": "^14.16.0 || >=16.10.0"
}
},
"node_modules/object-assign": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
@ -8335,13 +8025,6 @@
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/ohash": {
"version": "2.0.11",
"resolved": "https://registry.npmjs.org/ohash/-/ohash-2.0.11.tgz",
"integrity": "sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ==",
"devOptional": true,
"license": "MIT"
},
"node_modules/on-finished": {
"version": "2.4.1",
"resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
@ -8580,20 +8263,6 @@
"node": ">=8"
}
},
"node_modules/pathe": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
"integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
"devOptional": true,
"license": "MIT"
},
"node_modules/perfect-debounce": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz",
"integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==",
"devOptional": true,
"license": "MIT"
},
"node_modules/pg": {
"version": "8.16.3",
"resolved": "https://registry.npmjs.org/pg/-/pg-8.16.3.tgz",
@ -8782,18 +8451,6 @@
"node": ">=8"
}
},
"node_modules/pkg-types": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.3.0.tgz",
"integrity": "sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==",
"devOptional": true,
"license": "MIT",
"dependencies": {
"confbox": "^0.2.2",
"exsolve": "^1.0.7",
"pathe": "^2.0.3"
}
},
"node_modules/postgres-array": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
@ -8887,32 +8544,6 @@
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/prisma": {
"version": "6.16.2",
"resolved": "https://registry.npmjs.org/prisma/-/prisma-6.16.2.tgz",
"integrity": "sha512-aRvldGE5UUJTtVmFiH3WfNFNiqFlAtePUxcI0UEGlnXCX7DqhiMT5TRYwncHFeA/Reca5W6ToXXyCMTeFPdSXA==",
"devOptional": true,
"hasInstallScript": true,
"license": "Apache-2.0",
"dependencies": {
"@prisma/config": "6.16.2",
"@prisma/engines": "6.16.2"
},
"bin": {
"prisma": "build/index.js"
},
"engines": {
"node": ">=18.18"
},
"peerDependencies": {
"typescript": ">=5.1.0"
},
"peerDependenciesMeta": {
"typescript": {
"optional": true
}
}
},
"node_modules/process": {
"version": "0.11.10",
"resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
@ -8982,7 +8613,7 @@
"version": "6.1.0",
"resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.1.0.tgz",
"integrity": "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==",
"devOptional": true,
"dev": true,
"funding": [
{
"type": "individual",
@ -9055,17 +8686,6 @@
"node": ">= 0.8"
}
},
"node_modules/rc9": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/rc9/-/rc9-2.1.2.tgz",
"integrity": "sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg==",
"devOptional": true,
"license": "MIT",
"dependencies": {
"defu": "^6.1.4",
"destr": "^2.0.3"
}
},
"node_modules/react-is": {
"version": "18.3.1",
"resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
@ -9904,13 +9524,6 @@
"dev": true,
"license": "MIT"
},
"node_modules/tinyexec": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.1.tgz",
"integrity": "sha512-5uC6DDlmeqiOwCPmK9jMSdOuZTh8bU39Ys6yidB+UTt5hfZUPGAypSgFRiEp+jbi9qH40BLDvy85jIU88wKSqw==",
"devOptional": true,
"license": "MIT"
},
"node_modules/tmpl": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz",
@ -10147,7 +9760,7 @@
"version": "5.9.2",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
"integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
"devOptional": true,
"dev": true,
"license": "Apache-2.0",
"bin": {
"tsc": "bin/tsc",

10
backend-node/package.json
View File

@ -11,23 +11,18 @@
"test:watch": "jest --watch",
"lint": "eslint src/ --ext .ts",
"lint:fix": "eslint src/ --ext .ts --fix",
"format": "prettier --write src/",
"prisma:generate": "prisma generate",
"prisma:migrate": "prisma migrate dev",
"prisma:studio": "prisma studio",
"prisma:seed": "prisma db seed"
"format": "prettier --write src/"
},
"keywords": [
"plm",
"nodejs",
"typescript",
"express",
"prisma"
"postgresql"
],
"author": "",
"license": "ISC",
"dependencies": {
"@prisma/client": "^6.16.2",
"@types/mssql": "^9.1.8",
"axios": "^1.11.0",
"bcryptjs": "^2.4.3",
@ -72,7 +67,6 @@
"jest": "^29.7.0",
"nodemon": "^3.1.10",
"prettier": "^3.1.0",
"prisma": "^6.16.2",
"supertest": "^6.3.4",
"ts-jest": "^29.1.1",
"ts-node": "^10.9.2",

3
backend-node/prisma/migrations/migration_lock.toml
View File

@ -1,3 +0,0 @@
# Please do not edit this file manually
# It should be added in your version-control system (i.e. Git)
provider = "postgresql"

4611
backend-node/prisma/schema.prisma
View File

File diff suppressed because it is too large Load Diff

30
backend-node/simple-test-user.js
View File

@ -1,30 +0,0 @@
const { Client } = require("pg");
async function createTestUser() {
const client = new Client({
connectionString: process.env.DATABASE_URL,
});
try {
await client.connect();
console.log("✅ 데이터베이스 연결 성공");
// 테스트용 사용자 생성
await client.query(`
INSERT INTO user_info (user_id, user_name, user_password, status, company_code, data_type)
VALUES ('admin', '테스트 관리자', 'f21b1ce8b08dc955bd4afff71b3db1fc', 'active', 'ILSHIN', 'PLM')
ON CONFLICT (user_id) DO UPDATE SET
user_name = EXCLUDED.user_name,
user_password = EXCLUDED.user_password,
status = EXCLUDED.status
`);
console.log("✅ 테스트 사용자 생성/업데이트 완료");
} catch (error) {
console.error("❌ 오류 발생:", error);
} finally {
await client.end();
}
}
createTestUser();

50
backend-node/src/config/database.ts
View File

@ -1,50 +0,0 @@
import { PrismaClient } from "@prisma/client";
import config from "./environment";
// Prisma 클라이언트 생성 함수
function createPrismaClient() {
return new PrismaClient({
datasources: {
db: {
url: config.databaseUrl,
},
},
log: config.debug ? ["query", "info", "warn", "error"] : ["error"],
});
}
// 단일 인스턴스 생성
const prisma = createPrismaClient();
// 데이터베이스 연결 테스트
async function testConnection() {
try {
await prisma.$connect();
} catch (error) {
console.error("❌ 데이터베이스 연결 실패:", error);
process.exit(1);
}
}
// 애플리케이션 종료 시 연결 해제
process.on("beforeExit", async () => {
await prisma.$disconnect();
});
process.on("SIGINT", async () => {
await prisma.$disconnect();
process.exit(0);
});
process.on("SIGTERM", async () => {
await prisma.$disconnect();
process.exit(0);
});
// 초기 연결 테스트 (개발 환경에서만)
if (config.nodeEnv === "development") {
testConnection();
}
// 기본 내보내기
export = prisma;

951
backend-node/src/controllers/adminController.ts
View File

File diff suppressed because it is too large Load Diff

274
backend-node/src/controllers/buttonActionStandardController.ts
View File

@ -1,8 +1,6 @@
import { Request, Response } from "express";
import { PrismaClient } from "@prisma/client";
import { AuthenticatedRequest } from "../types/auth";
const prisma = new PrismaClient();
import { query, queryOne, transaction } from "../database/db";
export class ButtonActionStandardController {
// 버튼 액션 목록 조회
@ -10,33 +8,36 @@ export class ButtonActionStandardController {
try {
const { active, category, search } = req.query;
const where: any = {};
const whereConditions: string[] = [];
const queryParams: any[] = [];
let paramIndex = 1;
if (active) {
where.is_active = active as string;
whereConditions.push(`is_active = $${paramIndex}`);
queryParams.push(active as string);
paramIndex++;
}
if (category) {
where.category = category as string;
whereConditions.push(`category = $${paramIndex}`);
queryParams.push(category as string);
paramIndex++;
}
if (search) {
where.OR = [
{ action_name: { contains: search as string, mode: "insensitive" } },
{
action_name_eng: {
contains: search as string,
mode: "insensitive",
},
},
{ description: { contains: search as string, mode: "insensitive" } },
];
whereConditions.push(`(action_name ILIKE $${paramIndex} OR action_name_eng ILIKE $${paramIndex} OR description ILIKE $${paramIndex})`);
queryParams.push(`%${search}%`);
paramIndex++;
}
const buttonActions = await prisma.button_action_standards.findMany({
where,
orderBy: [{ sort_order: "asc" }, { action_type: "asc" }],
});
const whereClause = whereConditions.length > 0
? `WHERE ${whereConditions.join(" AND ")}`
: "";
const buttonActions = await query<any>(
`SELECT * FROM button_action_standards ${whereClause} ORDER BY sort_order ASC, action_type ASC`,
queryParams
);
return res.json({
success: true,
@ -58,9 +59,10 @@ export class ButtonActionStandardController {
try {
const { actionType } = req.params;
const buttonAction = await prisma.button_action_standards.findUnique({
where: { action_type: actionType },
});
const buttonAction = await queryOne<any>(
"SELECT * FROM button_action_standards WHERE action_type = $1 LIMIT 1",
[actionType]
);
if (!buttonAction) {
return res.status(404).json({
@ -115,9 +117,10 @@ export class ButtonActionStandardController {
}
// 중복 체크
const existingAction = await prisma.button_action_standards.findUnique({
where: { action_type },
});
const existingAction = await queryOne<any>(
"SELECT * FROM button_action_standards WHERE action_type = $1 LIMIT 1",
[action_type]
);
if (existingAction) {
return res.status(409).json({
@ -126,28 +129,25 @@ export class ButtonActionStandardController {
});
}
const newButtonAction = await prisma.button_action_standards.create({
data: {
action_type,
action_name,
action_name_eng,
description,
category,
default_text,
default_text_eng,
default_icon,
default_color,
default_variant,
confirmation_required,
confirmation_message,
validation_rules,
action_config,
sort_order,
is_active,
created_by: req.user?.userId || "system",
updated_by: req.user?.userId || "system",
},
});
const [newButtonAction] = await query<any>(
`INSERT INTO button_action_standards (
action_type, action_name, action_name_eng, description, category,
default_text, default_text_eng, default_icon, default_color, default_variant,
confirmation_required, confirmation_message, validation_rules, action_config,
sort_order, is_active, created_by, updated_by, created_date, updated_date
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, NOW(), NOW())
RETURNING *`,
[
action_type, action_name, action_name_eng, description, category,
default_text, default_text_eng, default_icon, default_color, default_variant,
confirmation_required, confirmation_message,
validation_rules ? JSON.stringify(validation_rules) : null,
action_config ? JSON.stringify(action_config) : null,
sort_order, is_active,
req.user?.userId || "system",
req.user?.userId || "system"
]
);
return res.status(201).json({
success: true,
@ -187,9 +187,10 @@ export class ButtonActionStandardController {
} = req.body;
// 존재 여부 확인
const existingAction = await prisma.button_action_standards.findUnique({
where: { action_type: actionType },
});
const existingAction = await queryOne<any>(
"SELECT * FROM button_action_standards WHERE action_type = $1 LIMIT 1",
[actionType]
);
if (!existingAction) {
return res.status(404).json({
@ -198,28 +199,101 @@ export class ButtonActionStandardController {
});
}
const updatedButtonAction = await prisma.button_action_standards.update({
where: { action_type: actionType },
data: {
action_name,
action_name_eng,
description,
category,
default_text,
default_text_eng,
default_icon,
default_color,
default_variant,
confirmation_required,
confirmation_message,
validation_rules,
action_config,
sort_order,
is_active,
updated_by: req.user?.userId || "system",
updated_date: new Date(),
},
});
const updateFields: string[] = [];
const updateParams: any[] = [];
let paramIndex = 1;
if (action_name !== undefined) {
updateFields.push(`action_name = $${paramIndex}`);
updateParams.push(action_name);
paramIndex++;
}
if (action_name_eng !== undefined) {
updateFields.push(`action_name_eng = $${paramIndex}`);
updateParams.push(action_name_eng);
paramIndex++;
}
if (description !== undefined) {
updateFields.push(`description = $${paramIndex}`);
updateParams.push(description);
paramIndex++;
}
if (category !== undefined) {
updateFields.push(`category = $${paramIndex}`);
updateParams.push(category);
paramIndex++;
}
if (default_text !== undefined) {
updateFields.push(`default_text = $${paramIndex}`);
updateParams.push(default_text);
paramIndex++;
}
if (default_text_eng !== undefined) {
updateFields.push(`default_text_eng = $${paramIndex}`);
updateParams.push(default_text_eng);
paramIndex++;
}
if (default_icon !== undefined) {
updateFields.push(`default_icon = $${paramIndex}`);
updateParams.push(default_icon);
paramIndex++;
}
if (default_color !== undefined) {
updateFields.push(`default_color = $${paramIndex}`);
updateParams.push(default_color);
paramIndex++;
}
if (default_variant !== undefined) {
updateFields.push(`default_variant = $${paramIndex}`);
updateParams.push(default_variant);
paramIndex++;
}
if (confirmation_required !== undefined) {
updateFields.push(`confirmation_required = $${paramIndex}`);
updateParams.push(confirmation_required);
paramIndex++;
}
if (confirmation_message !== undefined) {
updateFields.push(`confirmation_message = $${paramIndex}`);
updateParams.push(confirmation_message);
paramIndex++;
}
if (validation_rules !== undefined) {
updateFields.push(`validation_rules = $${paramIndex}`);
updateParams.push(validation_rules ? JSON.stringify(validation_rules) : null);
paramIndex++;
}
if (action_config !== undefined) {
updateFields.push(`action_config = $${paramIndex}`);
updateParams.push(action_config ? JSON.stringify(action_config) : null);
paramIndex++;
}
if (sort_order !== undefined) {
updateFields.push(`sort_order = $${paramIndex}`);
updateParams.push(sort_order);
paramIndex++;
}
if (is_active !== undefined) {
updateFields.push(`is_active = $${paramIndex}`);
updateParams.push(is_active);
paramIndex++;
}
updateFields.push(`updated_by = $${paramIndex}`);
updateParams.push(req.user?.userId || "system");
paramIndex++;
updateFields.push(`updated_date = $${paramIndex}`);
updateParams.push(new Date());
paramIndex++;
updateParams.push(actionType);
const [updatedButtonAction] = await query<any>(
`UPDATE button_action_standards SET ${updateFields.join(", ")}
WHERE action_type = $${paramIndex} RETURNING *`,
updateParams
);
return res.json({
success: true,
@ -242,9 +316,10 @@ export class ButtonActionStandardController {
const { actionType } = req.params;
// 존재 여부 확인
const existingAction = await prisma.button_action_standards.findUnique({
where: { action_type: actionType },
});
const existingAction = await queryOne<any>(
"SELECT * FROM button_action_standards WHERE action_type = $1 LIMIT 1",
[actionType]
);
if (!existingAction) {
return res.status(404).json({
@ -253,9 +328,10 @@ export class ButtonActionStandardController {
});
}
await prisma.button_action_standards.delete({
where: { action_type: actionType },
});
await query<any>(
"DELETE FROM button_action_standards WHERE action_type = $1",
[actionType]
);
return res.json({
success: true,
@ -287,18 +363,16 @@ export class ButtonActionStandardController {
}
// 트랜잭션으로 일괄 업데이트
await prisma.$transaction(
buttonActions.map((item) =>
prisma.button_action_standards.update({
where: { action_type: item.action_type },
data: {
sort_order: item.sort_order,
updated_by: req.user?.userId || "system",
updated_date: new Date(),
},
})
)
);
await transaction(async (client) => {
for (const item of buttonActions) {
await client.query(
`UPDATE button_action_standards
SET sort_order = $1, updated_by = $2, updated_date = NOW()
WHERE action_type = $3`,
[item.sort_order, req.user?.userId || "system", item.action_type]
);
}
});
return res.json({
success: true,
@ -317,19 +391,17 @@ export class ButtonActionStandardController {
// 버튼 액션 카테고리 목록 조회
static async getButtonActionCategories(req: Request, res: Response) {
try {
const categories = await prisma.button_action_standards.groupBy({
by: ["category"],
where: {
is_active: "Y",
},
_count: {
category: true,
},
});
const categories = await query<{ category: string; count: string }>(
`SELECT category, COUNT(*) as count
FROM button_action_standards
WHERE is_active = $1
GROUP BY category`,
["Y"]
);
const categoryList = categories.map((item) => ({
category: item.category,
count: item._count.category,
count: parseInt(item.count),
}));
return res.json({

6
backend-node/src/controllers/commonCodeController.ts
View File

@ -133,10 +133,10 @@ export class CommonCodeController {
} catch (error) {
logger.error("카테고리 생성 실패:", error);
// Prisma 에러 처리
// PostgreSQL 에러 처리
if (
error instanceof Error &&
error.message.includes("Unique constraint")
((error as any)?.code === "23505") || // PostgreSQL unique_violation
(error instanceof Error && error.message.includes("Unique constraint"))
) {
return res.status(409).json({
success: false,

4
backend-node/src/controllers/dataflowDiagramController.ts
View File

@ -154,7 +154,7 @@ export const createDataflowDiagram = async (req: Request, res: Response) => {
// 중복 이름 에러인지 먼저 확인 (로그 출력 전에)
const isDuplicateError =
(error && typeof error === "object" && (error as any).code === "P2002") || // Prisma unique constraint error code
(error && typeof error === "object" && (error as any).code === "23505") || // PostgreSQL unique_violation
(error instanceof Error &&
(error.message.includes("unique constraint") ||
error.message.includes("Unique constraint") ||
@ -236,7 +236,7 @@ export const updateDataflowDiagram = async (req: Request, res: Response) => {
} catch (error) {
// 중복 이름 에러인지 먼저 확인 (로그 출력 전에)
const isDuplicateError =
(error && typeof error === "object" && (error as any).code === "P2002") || // Prisma unique constraint error code
(error && typeof error === "object" && (error as any).code === "23505") || // PostgreSQL unique_violation
(error instanceof Error &&
(error.message.includes("unique constraint") ||
error.message.includes("Unique constraint") ||

48
backend-node/src/controllers/dataflowExecutionController.ts
View File

@ -1,12 +1,12 @@
/**
* 🔥 데이터플로우 실행 컨트롤러
*
*
* 버튼 제어에서 관계 실행 시 사용되는 컨트롤러
*/
import { Request, Response } from "express";
import { AuthenticatedRequest } from "../types/auth";
import prisma from "../config/database";
import { query } from "../database/db";
import logger from "../utils/logger";
/**
@ -146,18 +146,18 @@ async function executeInsert(tableName: string, data: Record<string, any>): Prom
const values = Object.values(data);
const placeholders = values.map((_, index) => `$${index + 1}`).join(', ');
const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders}) RETURNING *`;
logger.info(`INSERT 쿼리 실행:`, { query, values });
const insertQuery = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders}) RETURNING *`;
logger.info(`INSERT 쿼리 실행:`, { query: insertQuery, values });
const result = await query<any>(insertQuery, values);
const result = await prisma.$queryRawUnsafe(query, ...values);
return {
success: true,
action: 'insert',
tableName,
data: result,
affectedRows: Array.isArray(result) ? result.length : 1,
affectedRows: result.length,
};
} catch (error) {
logger.error(`INSERT 실행 오류:`, error);
@ -172,7 +172,7 @@ async function executeUpdate(tableName: string, data: Record<string, any>): Prom
try {
// ID 또는 기본키를 기준으로 업데이트
const { id, ...updateData } = data;
if (!id) {
throw new Error('UPDATE를 위한 ID가 필요합니다');
}
@ -180,20 +180,20 @@ async function executeUpdate(tableName: string, data: Record<string, any>): Prom
const setClause = Object.keys(updateData)
.map((key, index) => `${key} = $${index + 1}`)
.join(', ');
const values = Object.values(updateData);
const query = `UPDATE ${tableName} SET ${setClause} WHERE id = $${values.length + 1} RETURNING *`;
logger.info(`UPDATE 쿼리 실행:`, { query, values: [...values, id] });
const result = await prisma.$queryRawUnsafe(query, ...values, id);
const values = Object.values(updateData);
const updateQuery = `UPDATE ${tableName} SET ${setClause} WHERE id = $${values.length + 1} RETURNING *`;
logger.info(`UPDATE 쿼리 실행:`, { query: updateQuery, values: [...values, id] });
const result = await query<any>(updateQuery, [...values, id]);
return {
success: true,
action: 'update',
tableName,
data: result,
affectedRows: Array.isArray(result) ? result.length : 1,
affectedRows: result.length,
};
} catch (error) {
logger.error(`UPDATE 실행 오류:`, error);
@ -226,23 +226,23 @@ async function executeUpsert(tableName: string, data: Record<string, any>): Prom
async function executeDelete(tableName: string, data: Record<string, any>): Promise<any> {
try {
const { id } = data;
if (!id) {
throw new Error('DELETE를 위한 ID가 필요합니다');
}
const query = `DELETE FROM ${tableName} WHERE id = $1 RETURNING *`;
logger.info(`DELETE 쿼리 실행:`, { query, values: [id] });
const deleteQuery = `DELETE FROM ${tableName} WHERE id = $1 RETURNING *`;
logger.info(`DELETE 쿼리 실행:`, { query: deleteQuery, values: [id] });
const result = await query<any>(deleteQuery, [id]);
const result = await prisma.$queryRawUnsafe(query, id);
return {
success: true,
action: 'delete',
tableName,
data: result,
affectedRows: Array.isArray(result) ? result.length : 1,
affectedRows: result.length,
};
} catch (error) {
logger.error(`DELETE 실행 오류:`, error);

59
backend-node/src/controllers/entityReferenceController.ts
View File

@ -1,9 +1,7 @@
import { Request, Response } from "express";
import { PrismaClient } from "@prisma/client";
import { query, queryOne } from "../database/db";
import { logger } from "../utils/logger";
const prisma = new PrismaClient();
export interface EntityReferenceOption {
value: string;
label: string;
@ -39,12 +37,12 @@ export class EntityReferenceController {
});
// 컬럼 정보 조회
const columnInfo = await prisma.column_labels.findFirst({
where: {
table_name: tableName,
column_name: columnName,
},
});
const columnInfo = await queryOne<any>(
`SELECT * FROM column_labels
WHERE table_name = $1 AND column_name = $2
LIMIT 1`,
[tableName, columnName]
);
if (!columnInfo) {
return res.status(404).json({
@ -76,7 +74,7 @@ export class EntityReferenceController {
// 참조 테이블이 실제로 존재하는지 확인
try {
await prisma.$queryRawUnsafe(`SELECT 1 FROM ${referenceTable} LIMIT 1`);
await query<any>(`SELECT 1 FROM ${referenceTable} LIMIT 1`);
logger.info(
`Entity 참조 설정: ${tableName}.${columnName} -> ${referenceTable}.${referenceColumn} (display: ${displayColumn})`
);
@ -92,26 +90,26 @@ export class EntityReferenceController {
}
// 동적 쿼리로 참조 데이터 조회
let query = `SELECT ${referenceColumn}, ${displayColumn} as display_name FROM ${referenceTable}`;
let sqlQuery = `SELECT ${referenceColumn}, ${displayColumn} as display_name FROM ${referenceTable}`;
const queryParams: any[] = [];
// 검색 조건 추가
if (search) {
query += ` WHERE ${displayColumn} ILIKE $1`;
sqlQuery += ` WHERE ${displayColumn} ILIKE $1`;
queryParams.push(`%${search}%`);
}
query += ` ORDER BY ${displayColumn} LIMIT $${queryParams.length + 1}`;
sqlQuery += ` ORDER BY ${displayColumn} LIMIT $${queryParams.length + 1}`;
queryParams.push(Number(limit));
logger.info(`실행할 쿼리: ${query}`, {
logger.info(`실행할 쿼리: ${sqlQuery}`, {
queryParams,
referenceTable,
referenceColumn,
displayColumn,
});
const referenceData = await prisma.$queryRawUnsafe(query, ...queryParams);
const referenceData = await query<any>(sqlQuery, queryParams);
// 옵션 형태로 변환
const options: EntityReferenceOption[] = (referenceData as any[]).map(
@ -158,29 +156,22 @@ export class EntityReferenceController {
});
// code_info 테이블에서 코드 데이터 조회
let whereCondition: any = {
code_category: codeCategory,
is_active: "Y",
};
const queryParams: any[] = [codeCategory, 'Y'];
let sqlQuery = `
SELECT code_value, code_name
FROM code_info
WHERE code_category = $1 AND is_active = $2
`;
if (search) {
whereCondition.code_name = {
contains: String(search),
mode: "insensitive",
};
sqlQuery += ` AND code_name ILIKE $3`;
queryParams.push(`%${search}%`);
}
const codeData = await prisma.code_info.findMany({
where: whereCondition,
select: {
code_value: true,
code_name: true,
},
orderBy: {
code_name: "asc",
},
take: Number(limit),
});
sqlQuery += ` ORDER BY code_name ASC LIMIT $${queryParams.length + 1}`;
queryParams.push(Number(limit));
const codeData = await query<any>(sqlQuery, queryParams);
// 옵션 형태로 변환
const options: EntityReferenceOption[] = codeData.map((code) => ({

335
backend-node/src/controllers/fileController.ts
View File

@ -3,10 +3,8 @@ import { AuthenticatedRequest } from "../types/auth";
import multer from "multer";
import path from "path";
import fs from "fs";
import { PrismaClient } from "@prisma/client";
import { generateUUID } from "../utils/generateId";
const prisma = new PrismaClient();
import { query, queryOne } from "../database/db";
// 임시 토큰 저장소 (메모리 기반, 실제 운영에서는 Redis 사용 권장)
const tempTokens = new Map<string, { objid: string; expires: number }>();
@ -64,41 +62,44 @@ const storage = multer.diskStorage({
filename: (req, file, cb) => {
// 타임스탬프_원본파일명 형태로 저장 (회사코드는 디렉토리로 분리됨)
const timestamp = Date.now();
console.log("📁 파일명 처리:", {
originalname: file.originalname,
encoding: file.encoding,
mimetype: file.mimetype
mimetype: file.mimetype,
});
// UTF-8 인코딩 문제 해결: Buffer를 통한 올바른 디코딩
let decodedName;
try {
// 파일명이 깨진 경우 Buffer를 통해 올바르게 디코딩
const buffer = Buffer.from(file.originalname, 'latin1');
decodedName = buffer.toString('utf8');
console.log("📁 파일명 디코딩:", { original: file.originalname, decoded: decodedName });
const buffer = Buffer.from(file.originalname, "latin1");
decodedName = buffer.toString("utf8");
console.log("📁 파일명 디코딩:", {
original: file.originalname,
decoded: decodedName,
});
} catch (error) {
// 디코딩 실패 시 원본 사용
decodedName = file.originalname;
console.log("📁 파일명 디코딩 실패, 원본 사용:", file.originalname);
}
// 한국어를 포함한 유니코드 문자 보존하면서 안전한 파일명 생성
// 위험한 문자만 제거: / \ : * ? " < > |
const sanitizedName = decodedName
.replace(/[\/\\:*?"<>|]/g, "_") // 파일시스템에서 금지된 문자만 치환
.replace(/\s+/g, "_") // 공백을 언더스코어로 치환
.replace(/_{2,}/g, "_"); // 연속된 언더스코어를 하나로 축약
.replace(/[\/\\:*?"<>|]/g, "_") // 파일시스템에서 금지된 문자만 치환
.replace(/\s+/g, "_") // 공백을 언더스코어로 치환
.replace(/_{2,}/g, "_"); // 연속된 언더스코어를 하나로 축약
const savedFileName = `${timestamp}_${sanitizedName}`;
console.log("📁 파일명 변환:", {
original: file.originalname,
sanitized: sanitizedName,
saved: savedFileName
saved: savedFileName,
});
cb(null, savedFileName);
},
});
@ -169,7 +170,7 @@ const upload = multer({
"audio/ogg",
// Apple/맥 파일
"application/vnd.apple.pages", // .pages (Pages)
"application/vnd.apple.numbers", // .numbers (Numbers)
"application/vnd.apple.numbers", // .numbers (Numbers)
"application/vnd.apple.keynote", // .keynote (Keynote)
"application/x-iwork-pages-sffpages", // .pages (다른 MIME)
"application/x-iwork-numbers-sffnumbers", // .numbers (다른 MIME)
@ -246,14 +247,20 @@ export const uploadFiles = async (
// 파일명 디코딩 (파일 저장 시와 동일한 로직)
let decodedOriginalName;
try {
const buffer = Buffer.from(file.originalname, 'latin1');
decodedOriginalName = buffer.toString('utf8');
console.log("💾 DB 저장용 파일명 디코딩:", { original: file.originalname, decoded: decodedOriginalName });
const buffer = Buffer.from(file.originalname, "latin1");
decodedOriginalName = buffer.toString("utf8");
console.log("💾 DB 저장용 파일명 디코딩:", {
original: file.originalname,
decoded: decodedOriginalName,
});
} catch (error) {
decodedOriginalName = file.originalname;
console.log("💾 DB 저장용 파일명 디코딩 실패, 원본 사용:", file.originalname);
console.log(
"💾 DB 저장용 파일명 디코딩 실패, 원본 사용:",
file.originalname
);
}
// 파일 확장자 추출
const fileExt = path
.extname(decodedOriginalName)
@ -269,7 +276,7 @@ export const uploadFiles = async (
// 회사코드가 *인 경우 company_*로 변환
const actualCompanyCode = companyCode === "*" ? "company_*" : companyCode;
// 임시 파일을 최종 위치로 이동
const tempFilePath = file.path; // Multer가 저장한 임시 파일 경로
const finalUploadDir = getCompanyUploadDir(companyCode, dateFolder);
@ -283,27 +290,34 @@ export const uploadFiles = async (
const fullFilePath = `/uploads${relativePath}`;
// attach_file_info 테이블에 저장
const fileRecord = await prisma.attach_file_info.create({
data: {
objid: parseInt(
generateUUID().replace(/-/g, "").substring(0, 15),
16
),
target_objid: finalTargetObjid,
saved_file_name: file.filename,
real_file_name: decodedOriginalName,
doc_type: docType,
doc_type_name: docTypeName,
file_size: file.size,
file_ext: fileExt,
file_path: fullFilePath, // 회사별 디렉토리 포함된 경로
company_code: companyCode, // 회사코드 추가
writer: writer,
regdate: new Date(),
status: "ACTIVE",
parent_target_objid: parentTargetObjid,
},
});
const objidValue = parseInt(
generateUUID().replace(/-/g, "").substring(0, 15),
16
);
const [fileRecord] = await query<any>(
`INSERT INTO attach_file_info (
objid, target_objid, saved_file_name, real_file_name, doc_type, doc_type_name,
file_size, file_ext, file_path, company_code, writer, regdate, status, parent_target_objid
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
RETURNING *`,
[
objidValue,
finalTargetObjid,
file.filename,
decodedOriginalName,
docType,
docTypeName,
file.size,
fileExt,
fullFilePath,
companyCode,
writer,
new Date(),
"ACTIVE",
parentTargetObjid,
]
);
savedFiles.push({
objid: fileRecord.objid.toString(),
@ -350,14 +364,10 @@ export const deleteFile = async (
const { writer = "system" } = req.body;
// 파일 상태를 DELETED로 변경 (논리적 삭제)
const deletedFile = await prisma.attach_file_info.update({
where: {
objid: parseInt(objid),
},
data: {
status: "DELETED",
},
});
await query<any>(
"UPDATE attach_file_info SET status = $1 WHERE objid = $2",
["DELETED", parseInt(objid)]
);
res.json({
success: true,
@ -387,17 +397,12 @@ export const getLinkedFiles = async (
const baseTargetObjid = `${tableName}:${recordId}`;
// 기본 target_objid와 파일 컬럼 패턴 모두 조회 (tableName:recordId% 패턴)
const files = await prisma.attach_file_info.findMany({
where: {
target_objid: {
startsWith: baseTargetObjid, // tableName:recordId로 시작하는 모든 파일
},
status: "ACTIVE",
},
orderBy: {
regdate: "desc",
},
});
const files = await query<any>(
`SELECT * FROM attach_file_info
WHERE target_objid LIKE $1 AND status = $2
ORDER BY regdate DESC`,
[`${baseTargetObjid}%`, "ACTIVE"]
);
const fileList = files.map((file: any) => ({
objid: file.objid.toString(),
@ -441,24 +446,28 @@ export const getFileList = async (
try {
const { targetObjid, docType, companyCode } = req.query;
const where: any = {
status: "ACTIVE",
};
const whereConditions: string[] = ["status = $1"];
const queryParams: any[] = ["ACTIVE"];
let paramIndex = 2;
if (targetObjid) {
where.target_objid = targetObjid as string;
whereConditions.push(`target_objid = $${paramIndex}`);
queryParams.push(targetObjid as string);
paramIndex++;
}
if (docType) {
where.doc_type = docType as string;
whereConditions.push(`doc_type = $${paramIndex}`);
queryParams.push(docType as string);
paramIndex++;
}
const files = await prisma.attach_file_info.findMany({
where,
orderBy: {
regdate: "desc",
},
});
const files = await query<any>(
`SELECT * FROM attach_file_info
WHERE ${whereConditions.join(" AND ")}
ORDER BY regdate DESC`,
queryParams
);
const fileList = files.map((file: any) => ({
objid: file.objid.toString(),
@ -498,15 +507,16 @@ export const getComponentFiles = async (
res: Response
): Promise<void> => {
try {
const { screenId, componentId, tableName, recordId, columnName } = req.query;
const { screenId, componentId, tableName, recordId, columnName } =
req.query;
console.log("📂 [getComponentFiles] API 호출:", {
screenId,
componentId,
tableName,
recordId,
columnName,
user: req.user?.userId
user: req.user?.userId,
});
if (!screenId || !componentId) {
@ -519,51 +529,50 @@ export const getComponentFiles = async (
}
// 1. 템플릿 파일 조회 (화면 설계 시 업로드한 파일들)
const templateTargetObjid = `screen_files:${screenId}:${componentId}:${columnName || 'field_1'}`;
console.log("🔍 [getComponentFiles] 템플릿 파일 조회:", { templateTargetObjid });
const templateTargetObjid = `screen_files:${screenId}:${componentId}:${columnName || "field_1"}`;
console.log("🔍 [getComponentFiles] 템플릿 파일 조회:", {
templateTargetObjid,
});
// 모든 파일 조회해서 실제 저장된 target_objid 패턴 확인
const allFiles = await prisma.attach_file_info.findMany({
where: {
status: "ACTIVE",
},
select: {
target_objid: true,
real_file_name: true,
regdate: true,
},
orderBy: {
regdate: "desc",
},
take: 10,
});
console.log("🗂️ [getComponentFiles] 최근 저장된 파일들의 target_objid:", allFiles.map(f => ({ target_objid: f.target_objid, name: f.real_file_name })));
const templateFiles = await prisma.attach_file_info.findMany({
where: {
target_objid: templateTargetObjid,
status: "ACTIVE",
},
orderBy: {
regdate: "desc",
},
});
console.log("📁 [getComponentFiles] 템플릿 파일 결과:", templateFiles.length);
const allFiles = await query<any>(
`SELECT target_objid, real_file_name, regdate
FROM attach_file_info
WHERE status = $1
ORDER BY regdate DESC
LIMIT 10`,
["ACTIVE"]
);
console.log(
"🗂️ [getComponentFiles] 최근 저장된 파일들의 target_objid:",
allFiles.map((f) => ({
target_objid: f.target_objid,
name: f.real_file_name,
}))
);
const templateFiles = await query<any>(
`SELECT * FROM attach_file_info
WHERE target_objid = $1 AND status = $2
ORDER BY regdate DESC`,
[templateTargetObjid, "ACTIVE"]
);
console.log(
"📁 [getComponentFiles] 템플릿 파일 결과:",
templateFiles.length
);
// 2. 데이터 파일 조회 (실제 레코드와 연결된 파일들)
let dataFiles: any[] = [];
if (tableName && recordId && columnName) {
const dataTargetObjid = `${tableName}:${recordId}:${columnName}`;
dataFiles = await prisma.attach_file_info.findMany({
where: {
target_objid: dataTargetObjid,
status: "ACTIVE",
},
orderBy: {
regdate: "desc",
},
});
dataFiles = await query<any>(
`SELECT * FROM attach_file_info
WHERE target_objid = $1 AND status = $2
ORDER BY regdate DESC`,
[dataTargetObjid, "ACTIVE"]
);
}
// 파일 정보 포맷팅 함수
@ -584,13 +593,18 @@ export const getComponentFiles = async (
isTemplate, // 템플릿 파일 여부 표시
});
const formattedTemplateFiles = templateFiles.map(file => formatFileInfo(file, true));
const formattedDataFiles = dataFiles.map(file => formatFileInfo(file, false));
const formattedTemplateFiles = templateFiles.map((file) =>
formatFileInfo(file, true)
);
const formattedDataFiles = dataFiles.map((file) =>
formatFileInfo(file, false)
);
// 3. 전체 파일 목록 (데이터 파일 우선, 없으면 템플릿 파일 표시)
const totalFiles = formattedDataFiles.length > 0
? formattedDataFiles
: formattedTemplateFiles;
const totalFiles =
formattedDataFiles.length > 0
? formattedDataFiles
: formattedTemplateFiles;
res.json({
success: true,
@ -602,9 +616,10 @@ export const getComponentFiles = async (
dataCount: formattedDataFiles.length,
totalCount: totalFiles.length,
templateTargetObjid,
dataTargetObjid: tableName && recordId && columnName
? `${tableName}:${recordId}:${columnName}`
: null,
dataTargetObjid:
tableName && recordId && columnName
? `${tableName}:${recordId}:${columnName}`
: null,
},
});
} catch (error) {
@ -628,11 +643,10 @@ export const previewFile = async (
const { objid } = req.params;
const { serverFilename } = req.query;
const fileRecord = await prisma.attach_file_info.findUnique({
where: {
objid: parseInt(objid),
},
});
const fileRecord = await queryOne<any>(
"SELECT * FROM attach_file_info WHERE objid = $1 LIMIT 1",
[parseInt(objid)]
);
if (!fileRecord || fileRecord.status !== "ACTIVE") {
res.status(404).json({
@ -645,12 +659,12 @@ export const previewFile = async (
// 파일 경로에서 회사코드와 날짜 폴더 추출
const filePathParts = fileRecord.file_path!.split("/");
let companyCode = filePathParts[2] || "DEFAULT";
// company_* 처리 (실제 회사 코드로 변환)
if (companyCode === "company_*") {
companyCode = "company_*"; // 실제 디렉토리명 유지
}
const fileName = fileRecord.saved_file_name!;
// 파일 경로에 날짜 구조가 있는지 확인 (YYYY/MM/DD)
@ -673,7 +687,7 @@ export const previewFile = async (
fileName: fileName,
companyUploadDir: companyUploadDir,
finalFilePath: filePath,
fileExists: fs.existsSync(filePath)
fileExists: fs.existsSync(filePath),
});
if (!fs.existsSync(filePath)) {
@ -748,11 +762,10 @@ export const downloadFile = async (
try {
const { objid } = req.params;
const fileRecord = await prisma.attach_file_info.findUnique({
where: {
objid: parseInt(objid),
},
});
const fileRecord = await queryOne<any>(
`SELECT * FROM attach_file_info WHERE objid = $1`,
[parseInt(objid)]
);
if (!fileRecord || fileRecord.status !== "ACTIVE") {
res.status(404).json({
@ -765,12 +778,12 @@ export const downloadFile = async (
// 파일 경로에서 회사코드와 날짜 폴더 추출 (예: /uploads/company_*/2025/09/05/timestamp_filename.ext)
const filePathParts = fileRecord.file_path!.split("/");
let companyCode = filePathParts[2] || "DEFAULT"; // /uploads/company_*/2025/09/05/filename.ext에서 company_* 추출
// company_* 처리 (실제 회사 코드로 변환)
if (companyCode === "company_*") {
companyCode = "company_*"; // 실제 디렉토리명 유지
}
const fileName = fileRecord.saved_file_name!;
// 파일 경로에 날짜 구조가 있는지 확인 (YYYY/MM/DD)
@ -794,7 +807,7 @@ export const downloadFile = async (
fileName: fileName,
companyUploadDir: companyUploadDir,
finalFilePath: filePath,
fileExists: fs.existsSync(filePath)
fileExists: fs.existsSync(filePath),
});
if (!fs.existsSync(filePath)) {
@ -829,7 +842,10 @@ export const downloadFile = async (
/**
* Google Docs Viewer용 임시 공개 토큰 생성
*/
export const generateTempToken = async (req: AuthenticatedRequest, res: Response) => {
export const generateTempToken = async (
req: AuthenticatedRequest,
res: Response
) => {
try {
const { objid } = req.params;
@ -842,9 +858,10 @@ export const generateTempToken = async (req: AuthenticatedRequest, res: Response
}
// 파일 존재 확인
const fileRecord = await prisma.attach_file_info.findUnique({
where: { objid: objid },
});
const fileRecord = await queryOne<any>(
"SELECT * FROM attach_file_info WHERE objid = $1 LIMIT 1",
[objid]
);
if (!fileRecord) {
res.status(404).json({
@ -924,9 +941,10 @@ export const getFileByToken = async (req: Request, res: Response) => {
}
// 파일 정보 조회
const fileRecord = await prisma.attach_file_info.findUnique({
where: { objid: tokenData.objid },
});
const fileRecord = await queryOne<any>(
"SELECT * FROM attach_file_info WHERE objid = $1 LIMIT 1",
[tokenData.objid]
);
if (!fileRecord) {
res.status(404).json({
@ -947,7 +965,10 @@ export const getFileByToken = async (req: Request, res: Response) => {
if (filePathParts.length >= 6) {
dateFolder = `${filePathParts[3]}/${filePathParts[4]}/${filePathParts[5]}`;
}
const companyUploadDir = getCompanyUploadDir(companyCode, dateFolder || undefined);
const companyUploadDir = getCompanyUploadDir(
companyCode,
dateFolder || undefined
);
const filePath = path.join(companyUploadDir, fileName);
// 파일 존재 확인
@ -962,15 +983,18 @@ export const getFileByToken = async (req: Request, res: Response) => {
// MIME 타입 설정
const ext = path.extname(fileName).toLowerCase();
let contentType = "application/octet-stream";
const mimeTypes: { [key: string]: string } = {
".pdf": "application/pdf",
".doc": "application/msword",
".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
".docx":
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
".xls": "application/vnd.ms-excel",
".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
".xlsx":
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
".ppt": "application/vnd.ms-powerpoint",
".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
".pptx":
"application/vnd.openxmlformats-officedocument.presentationml.presentation",
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
".png": "image/png",
@ -984,7 +1008,10 @@ export const getFileByToken = async (req: Request, res: Response) => {
// 파일 헤더 설정
res.setHeader("Content-Type", contentType);
res.setHeader("Content-Disposition", `inline; filename="${encodeURIComponent(fileRecord.real_file_name!)}"`);
res.setHeader(
"Content-Disposition",
`inline; filename="${encodeURIComponent(fileRecord.real_file_name!)}"`
);
res.setHeader("Cache-Control", "public, max-age=300"); // 5분 캐시
// 파일 스트림 전송

96
backend-node/src/controllers/screenFileController.ts
View File

@ -1,9 +1,7 @@
import { Request, Response } from 'express';
import { AuthenticatedRequest } from '../middleware/authMiddleware';
import { PrismaClient } from '@prisma/client';
import logger from '../utils/logger';
const prisma = new PrismaClient();
import { Request, Response } from "express";
import { AuthenticatedRequest } from "../middleware/authMiddleware";
import { query } from "../database/db";
import logger from "../utils/logger";
/**
* 화면 컴포넌트별 파일 정보 조회 및 복원
@ -14,37 +12,33 @@ export const getScreenComponentFiles = async (
): Promise<void> => {
try {
const { screenId } = req.params;
logger.info(`화면 컴포넌트 파일 조회 시작: screenId=${screenId}`);
// screen_files: 접두사로 해당 화면의 모든 파일 조회
const targetObjidPattern = `screen_files:${screenId}:%`;
const files = await prisma.attach_file_info.findMany({
where: {
target_objid: {
startsWith: `screen_files:${screenId}:`
},
status: 'ACTIVE'
},
orderBy: {
regdate: 'desc'
}
});
const files = await query<any>(
`SELECT * FROM attach_file_info
WHERE target_objid LIKE $1
AND status = 'ACTIVE'
ORDER BY regdate DESC`,
[`screen_files:${screenId}:%`]
);
// 컴포넌트별로 파일 그룹화
const componentFiles: { [componentId: string]: any[] } = {};
files.forEach(file => {
files.forEach((file) => {
// target_objid 형식: screen_files:screenId:componentId:fieldName
const targetParts = file.target_objid?.split(':') || [];
const targetParts = file.target_objid?.split(":") || [];
if (targetParts.length >= 3) {
const componentId = targetParts[2];
if (!componentFiles[componentId]) {
componentFiles[componentId] = [];
}
componentFiles[componentId].push({
objid: file.objid.toString(),
savedFileName: file.saved_file_name,
@ -58,26 +52,27 @@ export const getScreenComponentFiles = async (
parentTargetObjid: file.parent_target_objid,
writer: file.writer,
regdate: file.regdate?.toISOString(),
status: file.status
status: file.status,
});
}
});
logger.info(`화면 컴포넌트 파일 조회 완료: ${Object.keys(componentFiles).length}개 컴포넌트, 총 ${files.length}개 파일`);
logger.info(
`화면 컴포넌트 파일 조회 완료: ${Object.keys(componentFiles).length}개 컴포넌트, 총 ${files.length}개 파일`
);
res.json({
success: true,
componentFiles: componentFiles,
totalFiles: files.length,
componentCount: Object.keys(componentFiles).length
componentCount: Object.keys(componentFiles).length,
});
} catch (error) {
logger.error('화면 컴포넌트 파일 조회 오류:', error);
logger.error("화면 컴포넌트 파일 조회 오류:", error);
res.status(500).json({
success: false,
message: '화면 컴포넌트 파일 조회 중 오류가 발생했습니다.',
error: error instanceof Error ? error.message : '알 수 없는 오류'
message: "화면 컴포넌트 파일 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류",
});
}
};
@ -91,25 +86,23 @@ export const getComponentFiles = async (
): Promise<void> => {
try {
const { screenId, componentId } = req.params;
logger.info(`컴포넌트 파일 조회: screenId=${screenId}, componentId=${componentId}`);
logger.info(
`컴포넌트 파일 조회: screenId=${screenId}, componentId=${componentId}`
);
// target_objid 패턴: screen_files:screenId:componentId:*
const targetObjidPattern = `screen_files:${screenId}:${componentId}:`;
const files = await prisma.attach_file_info.findMany({
where: {
target_objid: {
startsWith: targetObjidPattern
},
status: 'ACTIVE'
},
orderBy: {
regdate: 'desc'
}
});
const fileList = files.map(file => ({
const files = await query<any>(
`SELECT * FROM attach_file_info
WHERE target_objid LIKE $1
AND status = 'ACTIVE'
ORDER BY regdate DESC`,
[`${targetObjidPattern}%`]
);
const fileList = files.map((file) => ({
objid: file.objid.toString(),
savedFileName: file.saved_file_name,
realFileName: file.real_file_name,
@ -122,7 +115,7 @@ export const getComponentFiles = async (
parentTargetObjid: file.parent_target_objid,
writer: file.writer,
regdate: file.regdate?.toISOString(),
status: file.status
status: file.status,
}));
logger.info(`컴포넌트 파일 조회 완료: ${fileList.length}개 파일`);
@ -131,15 +124,14 @@ export const getComponentFiles = async (
success: true,
files: fileList,
componentId: componentId,
screenId: screenId
screenId: screenId,
});
} catch (error) {
logger.error('컴포넌트 파일 조회 오류:', error);
logger.error("컴포넌트 파일 조회 오류:", error);
res.status(500).json({
success: false,
message: '컴포넌트 파일 조회 중 오류가 발생했습니다.',
error: error instanceof Error ? error.message : '알 수 없는 오류'
message: "컴포넌트 파일 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류",
});
}
};

252
backend-node/src/controllers/webTypeStandardController.ts
View File

@ -1,39 +1,51 @@
import { Request, Response } from "express";
import { PrismaClient } from "@prisma/client";
import { query, queryOne, transaction } from "../database/db";
import { AuthenticatedRequest } from "../types/auth";
const prisma = new PrismaClient();
export class WebTypeStandardController {
// 웹타입 목록 조회
static async getWebTypes(req: Request, res: Response) {
try {
const { active, category, search } = req.query;
const where: any = {};
// 동적 WHERE 절 생성
const whereConditions: string[] = [];
const queryParams: any[] = [];
let paramIndex = 1;
if (active) {
where.is_active = active as string;
whereConditions.push(`is_active = $${paramIndex}`);
queryParams.push(active);
paramIndex++;
}
if (category) {
where.category = category as string;
whereConditions.push(`category = $${paramIndex}`);
queryParams.push(category);
paramIndex++;
}
if (search) {
where.OR = [
{ type_name: { contains: search as string, mode: "insensitive" } },
{
type_name_eng: { contains: search as string, mode: "insensitive" },
},
{ description: { contains: search as string, mode: "insensitive" } },
];
if (search && typeof search === "string") {
whereConditions.push(`(
type_name ILIKE $${paramIndex} OR
type_name_eng ILIKE $${paramIndex} OR
description ILIKE $${paramIndex}
)`);
queryParams.push(`%${search}%`);
paramIndex++;
}
const webTypes = await prisma.web_type_standards.findMany({
where,
orderBy: [{ sort_order: "asc" }, { web_type: "asc" }],
});
const whereClause =
whereConditions.length > 0
? `WHERE ${whereConditions.join(" AND ")}`
: "";
const webTypes = await query<any>(
`SELECT * FROM web_type_standards
${whereClause}
ORDER BY sort_order ASC, web_type ASC`,
queryParams
);
return res.json({
success: true,
@ -55,9 +67,10 @@ export class WebTypeStandardController {
try {
const { webType } = req.params;
const webTypeData = await prisma.web_type_standards.findUnique({
where: { web_type: webType },
});
const webTypeData = await queryOne<any>(
`SELECT * FROM web_type_standards WHERE web_type = $1`,
[webType]
);
if (!webTypeData) {
return res.status(404).json({
@ -109,9 +122,10 @@ export class WebTypeStandardController {
}
// 중복 체크
const existingWebType = await prisma.web_type_standards.findUnique({
where: { web_type },
});
const existingWebType = await queryOne<any>(
`SELECT web_type FROM web_type_standards WHERE web_type = $1`,
[web_type]
);
if (existingWebType) {
return res.status(409).json({
@ -120,8 +134,15 @@ export class WebTypeStandardController {
});
}
const newWebType = await prisma.web_type_standards.create({
data: {
const [newWebType] = await query<any>(
`INSERT INTO web_type_standards (
web_type, type_name, type_name_eng, description, category,
component_name, config_panel, default_config, validation_rules,
default_style, input_properties, sort_order, is_active,
created_by, created_date, updated_by, updated_date
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, NOW(), $15, NOW())
RETURNING *`,
[
web_type,
type_name,
type_name_eng,
@ -135,10 +156,10 @@ export class WebTypeStandardController {
input_properties,
sort_order,
is_active,
created_by: req.user?.userId || "system",
updated_by: req.user?.userId || "system",
},
});
req.user?.userId || "system",
req.user?.userId || "system",
]
);
return res.status(201).json({
success: true,
@ -174,37 +195,106 @@ export class WebTypeStandardController {
is_active,
} = req.body;
// 존재 여부 확인
const existingWebType = await prisma.web_type_standards.findUnique({
where: { web_type: webType },
});
// 동적 UPDATE 쿼리 생성
const updateFields: string[] = [];
const updateValues: any[] = [];
let paramIndex = 1;
if (!existingWebType) {
if (type_name !== undefined) {
updateFields.push(`type_name = $${paramIndex}`);
updateValues.push(type_name);
paramIndex++;
}
if (type_name_eng !== undefined) {
updateFields.push(`type_name_eng = $${paramIndex}`);
updateValues.push(type_name_eng);
paramIndex++;
}
if (description !== undefined) {
updateFields.push(`description = $${paramIndex}`);
updateValues.push(description);
paramIndex++;
}
if (category !== undefined) {
updateFields.push(`category = $${paramIndex}`);
updateValues.push(category);
paramIndex++;
}
if (component_name !== undefined) {
updateFields.push(`component_name = $${paramIndex}`);
updateValues.push(component_name);
paramIndex++;
}
if (config_panel !== undefined) {
updateFields.push(`config_panel = $${paramIndex}`);
updateValues.push(config_panel);
paramIndex++;
}
if (default_config !== undefined) {
updateFields.push(`default_config = $${paramIndex}`);
updateValues.push(default_config);
paramIndex++;
}
if (validation_rules !== undefined) {
updateFields.push(`validation_rules = $${paramIndex}`);
updateValues.push(validation_rules);
paramIndex++;
}
if (default_style !== undefined) {
updateFields.push(`default_style = $${paramIndex}`);
updateValues.push(default_style);
paramIndex++;
}
if (input_properties !== undefined) {
updateFields.push(`input_properties = $${paramIndex}`);
updateValues.push(input_properties);
paramIndex++;
}
if (sort_order !== undefined) {
updateFields.push(`sort_order = $${paramIndex}`);
updateValues.push(sort_order);
paramIndex++;
}
if (is_active !== undefined) {
updateFields.push(`is_active = $${paramIndex}`);
updateValues.push(is_active);
paramIndex++;
}
// updated_by, updated_date는 항상 추가
updateFields.push(`updated_by = $${paramIndex}`);
updateValues.push(req.user?.userId || "system");
paramIndex++;
updateFields.push(`updated_date = NOW()`);
if (updateFields.length === 2) {
// updated_by, updated_date만 있는 경우 = 수정할 내용이 없음
return res.status(400).json({
success: false,
message: "수정할 내용이 없습니다.",
});
}
// WHERE 조건용 파라미터 추가
updateValues.push(webType);
const result = await query<any>(
`UPDATE web_type_standards
SET ${updateFields.join(", ")}
WHERE web_type = $${paramIndex}
RETURNING *`,
updateValues
);
if (result.length === 0) {
return res.status(404).json({
success: false,
message: "해당 웹타입을 찾을 수 없습니다.",
});
}
const updatedWebType = await prisma.web_type_standards.update({
where: { web_type: webType },
data: {
type_name,
type_name_eng,
description,
category,
component_name,
config_panel,
default_config,
validation_rules,
default_style,
input_properties,
sort_order,
is_active,
updated_by: req.user?.userId || "system",
updated_date: new Date(),
},
});
const updatedWebType = result[0];
return res.json({
success: true,
@ -226,22 +316,18 @@ export class WebTypeStandardController {
try {
const { webType } = req.params;
// 존재 여부 확인
const existingWebType = await prisma.web_type_standards.findUnique({
where: { web_type: webType },
});
const result = await query<any>(
`DELETE FROM web_type_standards WHERE web_type = $1 RETURNING *`,
[webType]
);
if (!existingWebType) {
if (result.length === 0) {
return res.status(404).json({
success: false,
message: "해당 웹타입을 찾을 수 없습니다.",
});
}
await prisma.web_type_standards.delete({
where: { web_type: webType },
});
return res.json({
success: true,
message: "웹타입이 성공적으로 삭제되었습니다.",
@ -272,18 +358,16 @@ export class WebTypeStandardController {
}
// 트랜잭션으로 일괄 업데이트
await prisma.$transaction(
webTypes.map((item) =>
prisma.web_type_standards.update({
where: { web_type: item.web_type },
data: {
sort_order: item.sort_order,
updated_by: req.user?.userId || "system",
updated_date: new Date(),
},
})
)
);
await transaction(async (client) => {
for (const item of webTypes) {
await client.query(
`UPDATE web_type_standards
SET sort_order = $1, updated_by = $2, updated_date = NOW()
WHERE web_type = $3`,
[item.sort_order, req.user?.userId || "system", item.web_type]
);
}
});
return res.json({
success: true,
@ -302,19 +386,17 @@ export class WebTypeStandardController {
// 웹타입 카테고리 목록 조회
static async getWebTypeCategories(req: Request, res: Response) {
try {
const categories = await prisma.web_type_standards.groupBy({
by: ["category"],
where: {
is_active: "Y",
},
_count: {
category: true,
},
});
const categories = await query<{ category: string; count: string }>(
`SELECT category, COUNT(*) as count
FROM web_type_standards
WHERE is_active = 'Y'
GROUP BY category`,
[]
);
const categoryList = categories.map((item) => ({
category: item.category,
count: item._count.category,
count: parseInt(item.count, 10),
}));
return res.json({

3
backend-node/src/database/db.ts
View File

@ -259,6 +259,9 @@ export function getPoolStatus() {
};
}
// Pool 직접 접근 (필요한 경우)
export { pool };
// 기본 익스포트 (편의성)
export default {
query,

29
backend-node/src/middleware/errorHandler.ts
View File

@ -25,16 +25,25 @@ export const errorHandler = (
let error = { ...err };
error.message = err.message;
// Prisma 에러 처리
if (err.name === "PrismaClientKnownRequestError") {
const message = "데이터베이스 요청 오류가 발생했습니다.";
error = new AppError(message, 400);
}
// Prisma 유효성 검증 에러
if (err.name === "PrismaClientValidationError") {
const message = "입력 데이터가 유효하지 않습니다.";
error = new AppError(message, 400);
// PostgreSQL 에러 처리 (pg 라이브러리)
if ((err as any).code) {
const pgError = err as any;
// PostgreSQL 에러 코드 참조: https://www.postgresql.org/docs/current/errcodes-appendix.html
if (pgError.code === "23505") {
// unique_violation
error = new AppError("중복된 데이터가 존재합니다.", 400);
} else if (pgError.code === "23503") {
// foreign_key_violation
error = new AppError("참조 무결성 제약 조건 위반입니다.", 400);
} else if (pgError.code === "23502") {
// not_null_violation
error = new AppError("필수 입력값이 누락되었습니다.", 400);
} else if (pgError.code.startsWith("23")) {
// 기타 무결성 제약 조건 위반
error = new AppError("데이터 무결성 제약 조건 위반입니다.", 400);
} else {
error = new AppError("데이터베이스 오류가 발생했습니다.", 500);
}
}
// JWT 에러 처리

20
backend-node/src/routes/companyManagementRoutes.ts
View File

@ -3,10 +3,9 @@ import { authenticateToken } from "../middleware/authMiddleware";
import { AuthenticatedRequest } from "../types/auth";
import { logger } from "../utils/logger";
import { FileSystemManager } from "../utils/fileSystemManager";
import { PrismaClient } from "@prisma/client";
import { query, queryOne } from "../database/db";
const router = express.Router();
const prisma = new PrismaClient();
// 모든 라우트에 인증 미들웨어 적용
router.use(authenticateToken);
@ -29,9 +28,10 @@ router.delete(
});
// 1. 회사 존재 확인
const existingCompany = await prisma.company_mng.findUnique({
where: { company_code: companyCode },
});
const existingCompany = await queryOne<any>(
`SELECT * FROM company_mng WHERE company_code = $1`,
[companyCode]
);
if (!existingCompany) {
res.status(404).json({
@ -58,12 +58,10 @@ router.delete(
}
// 3. 데이터베이스에서 회사 삭제 (soft delete)
await prisma.company_mng.update({
where: { company_code: companyCode },
data: {
status: "deleted",
},
});
await query(
`UPDATE company_mng SET status = 'deleted' WHERE company_code = $1`,
[companyCode]
);
logger.info("회사 삭제 완료", {
companyCode,

7
backend-node/src/routes/ddlRoutes.ts
View File

@ -10,6 +10,7 @@ import {
validateDDLPermission,
} from "../middleware/superAdminMiddleware";
import { authenticateToken } from "../middleware/authMiddleware";
import { query } from "../database/db";
const router = express.Router();
@ -180,11 +181,7 @@ router.get("/info", authenticateToken, requireSuperAdmin, (req, res) => {
router.get("/health", authenticateToken, async (req, res) => {
try {
// 기본적인 데이터베이스 연결 테스트
const { PrismaClient } = await import("@prisma/client");
const prisma = new PrismaClient();
await prisma.$queryRaw`SELECT 1`;
await prisma.$disconnect();
await query("SELECT 1");
res.json({
success: true,

75
backend-node/src/services/adminService.ts
View File

@ -1,7 +1,5 @@
import { logger } from "../utils/logger";
// 🔧 Prisma 클라이언트 중복 생성 방지 - 기존 인스턴스 재사용
import prisma = require("../config/database");
import { query, queryOne } from "../database/db";
export class AdminService {
/**
@ -13,9 +11,10 @@ export class AdminService {
const { userLang = "ko" } = paramMap;
// 기존 Java의 selectAdminMenuList 쿼리를 Prisma로 포팅
// WITH RECURSIVE 쿼리를 Prisma의 $queryRaw로 구현
const menuList = await prisma.$queryRaw<any[]>`
// 기존 Java의 selectAdminMenuList 쿼리를 Raw Query로 포팅
// WITH RECURSIVE 쿼리 구현
const menuList = await query<any>(
`
WITH RECURSIVE v_menu(
LEVEL,
MENU_TYPE,
@ -62,14 +61,14 @@ export class AdminService {
JOIN MULTI_LANG_TEXT MLT ON MLKM.key_id = MLT.key_id
WHERE MLKM.lang_key = MENU.LANG_KEY
AND (MLKM.company_code = MENU.COMPANY_CODE OR (MENU.COMPANY_CODE IS NULL AND MLKM.company_code = '*'))
AND MLT.lang_code = ${userLang}
AND MLT.lang_code = $1
LIMIT 1),
(SELECT MLT.lang_text
FROM MULTI_LANG_KEY_MASTER MLKM
JOIN MULTI_LANG_TEXT MLT ON MLKM.key_id = MLT.key_id
WHERE MLKM.lang_key = MENU.LANG_KEY
AND MLKM.company_code = '*'
AND MLT.lang_code = ${userLang}
AND MLT.lang_code = $1
LIMIT 1),
MENU.MENU_NAME_KOR
),
@ -80,14 +79,14 @@ export class AdminService {
JOIN MULTI_LANG_TEXT MLT ON MLKM.key_id = MLT.key_id
WHERE MLKM.lang_key = MENU.LANG_KEY_DESC
AND (MLKM.company_code = MENU.COMPANY_CODE OR (MENU.COMPANY_CODE IS NULL AND MLKM.company_code = '*'))
AND MLT.lang_code = ${userLang}
AND MLT.lang_code = $1
LIMIT 1),
(SELECT MLT.lang_text
FROM MULTI_LANG_KEY_MASTER MLKM
JOIN MULTI_LANG_TEXT MLT ON MLKM.key_id = MLT.key_id
WHERE MLKM.lang_key = MENU.LANG_KEY_DESC
AND MLKM.company_code = '*'
AND MLT.lang_code = ${userLang}
AND MLT.lang_code = $1
LIMIT 1),
MENU.MENU_DESC
)
@ -125,14 +124,14 @@ export class AdminService {
JOIN MULTI_LANG_TEXT MLT ON MLKM.key_id = MLT.key_id
WHERE MLKM.lang_key = MENU_SUB.LANG_KEY
AND (MLKM.company_code = MENU_SUB.COMPANY_CODE OR (MENU_SUB.COMPANY_CODE IS NULL AND MLKM.company_code = '*'))
AND MLT.lang_code = ${userLang}
AND MLT.lang_code = $1
LIMIT 1),
(SELECT MLT.lang_text
FROM MULTI_LANG_KEY_MASTER MLKM
JOIN MULTI_LANG_TEXT MLT ON MLKM.key_id = MLT.key_id
WHERE MLKM.lang_key = MENU_SUB.LANG_KEY
AND MLKM.company_code = '*'
AND MLT.lang_code = ${userLang}
AND MLT.lang_code = $1
LIMIT 1),
MENU_SUB.MENU_NAME_KOR
),
@ -143,14 +142,14 @@ export class AdminService {
JOIN MULTI_LANG_TEXT MLT ON MLKM.key_id = MLT.key_id
WHERE MLKM.lang_key = MENU_SUB.LANG_KEY_DESC
AND (MLKM.company_code = MENU_SUB.COMPANY_CODE OR (MENU_SUB.COMPANY_CODE IS NULL AND MLKM.company_code = '*'))
AND MLT.lang_code = ${userLang}
AND MLT.lang_code = $1
LIMIT 1),
(SELECT MLT.lang_text
FROM MULTI_LANG_KEY_MASTER MLKM
JOIN MULTI_LANG_TEXT MLT ON MLKM.key_id = MLT.key_id
WHERE MLKM.lang_key = MENU_SUB.LANG_KEY_DESC
AND MLKM.company_code = '*'
AND MLT.lang_code = ${userLang}
AND MLT.lang_code = $1
LIMIT 1),
MENU_SUB.MENU_DESC
)
@ -190,7 +189,9 @@ export class AdminService {
LEFT JOIN COMPANY_MNG CM ON A.COMPANY_CODE = CM.COMPANY_CODE
WHERE 1 = 1
ORDER BY PATH, SEQ
`;
`,
[userLang]
);
logger.info(`관리자 메뉴 목록 조회 결과: ${menuList.length}개`);
if (menuList.length > 0) {
@ -213,8 +214,9 @@ export class AdminService {
const { userLang = "ko" } = paramMap;
// 기존 Java의 selectUserMenuList 쿼리를 Prisma로 포팅
const menuList = await prisma.$queryRaw<any[]>`
// 기존 Java의 selectUserMenuList 쿼리를 Raw Query로 포팅
const menuList = await query<any>(
`
WITH RECURSIVE v_menu(
LEVEL,
MENU_TYPE,
@ -310,12 +312,14 @@ export class AdminService {
FROM v_menu A
LEFT JOIN COMPANY_MNG CM ON A.COMPANY_CODE = CM.COMPANY_CODE
LEFT JOIN MULTI_LANG_KEY_MASTER MLKM_NAME ON A.LANG_KEY = MLKM_NAME.lang_key
LEFT JOIN MULTI_LANG_TEXT MLT_NAME ON MLKM_NAME.key_id = MLT_NAME.key_id AND MLT_NAME.lang_code = ${userLang}
LEFT JOIN MULTI_LANG_TEXT MLT_NAME ON MLKM_NAME.key_id = MLT_NAME.key_id AND MLT_NAME.lang_code = $1
LEFT JOIN MULTI_LANG_KEY_MASTER MLKM_DESC ON A.LANG_KEY_DESC = MLKM_DESC.lang_key
LEFT JOIN MULTI_LANG_TEXT MLT_DESC ON MLKM_DESC.key_id = MLT_DESC.key_id AND MLT_DESC.lang_code = ${userLang}
LEFT JOIN MULTI_LANG_TEXT MLT_DESC ON MLKM_DESC.key_id = MLT_DESC.key_id AND MLT_DESC.lang_code = $1
WHERE 1 = 1
ORDER BY PATH, SEQ
`;
`,
[userLang]
);
logger.info(`사용자 메뉴 목록 조회 결과: ${menuList.length}개`);
if (menuList.length > 0) {
@ -336,32 +340,31 @@ export class AdminService {
try {
logger.info(`AdminService.getMenuInfo 시작 - menuId: ${menuId}`);
// Prisma ORM을 사용한 메뉴 정보 조회 (회사 정보 포함)
const menuInfo = await prisma.menu_info.findUnique({
where: {
objid: Number(menuId),
},
include: {
company: {
select: {
company_name: true,
},
},
},
});
// Raw Query를 사용한 메뉴 정보 조회 (회사 정보 포함)
const menuResult = await query<any>(
`SELECT
m.*,
c.company_name
FROM menu_info m
LEFT JOIN company_mng c ON m.company_code = c.company_code
WHERE m.objid = $1::numeric`,
[menuId]
);
if (!menuInfo) {
if (!menuResult || menuResult.length === 0) {
return null;
}
const menuInfo = menuResult[0];
// 응답 형식 조정 (기존 형식과 호환성 유지)
const result = {
...menuInfo,
objid: menuInfo.objid.toString(), // BigInt를 문자열로 변환
objid: menuInfo.objid?.toString(),
menu_type: menuInfo.menu_type?.toString(),
parent_obj_id: menuInfo.parent_obj_id?.toString(),
seq: menuInfo.seq?.toString(),
company_name: menuInfo.company?.company_name || "미지정",
company_name: menuInfo.company_name || "미지정",
};
logger.info("메뉴 정보 조회 결과:", result);

336
backend-node/src/services/batchExecutionLogService.ts
View File

@ -1,13 +1,13 @@
// 배치 실행 로그 서비스
// 작성일: 2024-12-24
import prisma from "../config/database";
import { query, queryOne } from "../database/db";
import {
BatchExecutionLog,
CreateBatchExecutionLogRequest,
UpdateBatchExecutionLogRequest,
BatchExecutionLogFilter,
BatchExecutionLogWithConfig
BatchExecutionLogWithConfig,
} from "../types/batchExecutionLogTypes";
import { ApiResponse } from "../types/batchTypes";
@ -25,55 +25,75 @@ export class BatchExecutionLogService {
start_date,
end_date,
page = 1,
limit = 50
limit = 50,
} = filter;
const skip = (page - 1) * limit;
const take = limit;
// WHERE 조건 구성
const where: any = {};
const whereConditions: string[] = [];
const params: any[] = [];
let paramIndex = 1;
if (batch_config_id) {
where.batch_config_id = batch_config_id;
}
if (execution_status) {
where.execution_status = execution_status;
}
if (start_date || end_date) {
where.start_time = {};
if (start_date) {
where.start_time.gte = start_date;
}
if (end_date) {
where.start_time.lte = end_date;
}
whereConditions.push(`bel.batch_config_id = $${paramIndex++}`);
params.push(batch_config_id);
}
// 로그 조회
const [logs, total] = await Promise.all([
prisma.batch_execution_logs.findMany({
where,
include: {
batch_config: {
select: {
id: true,
batch_name: true,
description: true,
cron_schedule: true,
is_active: true
}
}
},
orderBy: { start_time: 'desc' },
skip,
take
}),
prisma.batch_execution_logs.count({ where })
if (execution_status) {
whereConditions.push(`bel.execution_status = $${paramIndex++}`);
params.push(execution_status);
}
if (start_date) {
whereConditions.push(`bel.start_time >= $${paramIndex++}`);
params.push(start_date);
}
if (end_date) {
whereConditions.push(`bel.start_time <= $${paramIndex++}`);
params.push(end_date);
}
const whereClause =
whereConditions.length > 0
? `WHERE ${whereConditions.join(" AND ")}`
: "";
// 로그 조회 (batch_config 정보 포함)
const sql = `
SELECT
bel.*,
json_build_object(
'id', bc.id,
'batch_name', bc.batch_name,
'description', bc.description,
'cron_schedule', bc.cron_schedule,
'is_active', bc.is_active
) as batch_config
FROM batch_execution_logs bel
LEFT JOIN batch_configs bc ON bel.batch_config_id = bc.id
${whereClause}
ORDER BY bel.start_time DESC
LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
`;
const countSql = `
SELECT COUNT(*) as count
FROM batch_execution_logs bel
${whereClause}
`;
params.push(take, skip);
const [logs, countResult] = await Promise.all([
query<any>(sql, params),
query<{ count: number }>(countSql, params.slice(0, -2)),
]);
const total = parseInt(countResult[0]?.count?.toString() || "0", 10);
return {
success: true,
data: logs as BatchExecutionLogWithConfig[],
@ -81,15 +101,15 @@ export class BatchExecutionLogService {
page,
limit,
total,
totalPages: Math.ceil(total / limit)
}
totalPages: Math.ceil(total / limit),
},
};
} catch (error) {
console.error("배치 실행 로그 조회 실패:", error);
return {
success: false,
message: "배치 실행 로그 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -101,34 +121,40 @@ export class BatchExecutionLogService {
data: CreateBatchExecutionLogRequest
): Promise<ApiResponse<BatchExecutionLog>> {
try {
const log = await prisma.batch_execution_logs.create({
data: {
batch_config_id: data.batch_config_id,
execution_status: data.execution_status,
start_time: data.start_time || new Date(),
end_time: data.end_time,
duration_ms: data.duration_ms,
total_records: data.total_records || 0,
success_records: data.success_records || 0,
failed_records: data.failed_records || 0,
error_message: data.error_message,
error_details: data.error_details,
server_name: data.server_name || process.env.HOSTNAME || 'unknown',
process_id: data.process_id || process.pid?.toString()
}
});
const log = await queryOne<BatchExecutionLog>(
`INSERT INTO batch_execution_logs (
batch_config_id, execution_status, start_time, end_time,
duration_ms, total_records, success_records, failed_records,
error_message, error_details, server_name, process_id
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
RETURNING *`,
[
data.batch_config_id,
data.execution_status,
data.start_time || new Date(),
data.end_time,
data.duration_ms,
data.total_records || 0,
data.success_records || 0,
data.failed_records || 0,
data.error_message,
data.error_details,
data.server_name || process.env.HOSTNAME || "unknown",
data.process_id || process.pid?.toString(),
]
);
return {
success: true,
data: log as BatchExecutionLog,
message: "배치 실행 로그가 생성되었습니다."
message: "배치 실행 로그가 생성되었습니다.",
};
} catch (error) {
console.error("배치 실행 로그 생성 실패:", error);
return {
success: false,
message: "배치 실행 로그 생성 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -141,31 +167,65 @@ export class BatchExecutionLogService {
data: UpdateBatchExecutionLogRequest
): Promise<ApiResponse<BatchExecutionLog>> {
try {
const log = await prisma.batch_execution_logs.update({
where: { id },
data: {
execution_status: data.execution_status,
end_time: data.end_time,
duration_ms: data.duration_ms,
total_records: data.total_records,
success_records: data.success_records,
failed_records: data.failed_records,
error_message: data.error_message,
error_details: data.error_details
}
});
// 동적 UPDATE 쿼리 생성
const updates: string[] = [];
const params: any[] = [];
let paramIndex = 1;
if (data.execution_status !== undefined) {
updates.push(`execution_status = $${paramIndex++}`);
params.push(data.execution_status);
}
if (data.end_time !== undefined) {
updates.push(`end_time = $${paramIndex++}`);
params.push(data.end_time);
}
if (data.duration_ms !== undefined) {
updates.push(`duration_ms = $${paramIndex++}`);
params.push(data.duration_ms);
}
if (data.total_records !== undefined) {
updates.push(`total_records = $${paramIndex++}`);
params.push(data.total_records);
}
if (data.success_records !== undefined) {
updates.push(`success_records = $${paramIndex++}`);
params.push(data.success_records);
}
if (data.failed_records !== undefined) {
updates.push(`failed_records = $${paramIndex++}`);
params.push(data.failed_records);
}
if (data.error_message !== undefined) {
updates.push(`error_message = $${paramIndex++}`);
params.push(data.error_message);
}
if (data.error_details !== undefined) {
updates.push(`error_details = $${paramIndex++}`);
params.push(data.error_details);
}
params.push(id);
const log = await queryOne<BatchExecutionLog>(
`UPDATE batch_execution_logs
SET ${updates.join(", ")}
WHERE id = $${paramIndex}
RETURNING *`,
params
);
return {
success: true,
data: log as BatchExecutionLog,
message: "배치 실행 로그가 업데이트되었습니다."
message: "배치 실행 로그가 업데이트되었습니다.",
};
} catch (error) {
console.error("배치 실행 로그 업데이트 실패:", error);
return {
success: false,
message: "배치 실행 로그 업데이트 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -175,20 +235,18 @@ export class BatchExecutionLogService {
*/
static async deleteExecutionLog(id: number): Promise<ApiResponse<void>> {
try {
await prisma.batch_execution_logs.delete({
where: { id }
});
await query(`DELETE FROM batch_execution_logs WHERE id = $1`, [id]);
return {
success: true,
message: "배치 실행 로그가 삭제되었습니다."
message: "배치 실행 로그가 삭제되었습니다.",
};
} catch (error) {
console.error("배치 실행 로그 삭제 실패:", error);
return {
success: false,
message: "배치 실행 로그 삭제 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -200,21 +258,24 @@ export class BatchExecutionLogService {
batchConfigId: number
): Promise<ApiResponse<BatchExecutionLog | null>> {
try {
const log = await prisma.batch_execution_logs.findFirst({
where: { batch_config_id: batchConfigId },
orderBy: { start_time: 'desc' }
});
const log = await queryOne<BatchExecutionLog>(
`SELECT * FROM batch_execution_logs
WHERE batch_config_id = $1
ORDER BY start_time DESC
LIMIT 1`,
[batchConfigId]
);
return {
success: true,
data: log as BatchExecutionLog | null
data: log || null,
};
} catch (error) {
console.error("최신 배치 실행 로그 조회 실패:", error);
return {
success: false,
message: "최신 배치 실행 로그 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -226,52 +287,73 @@ export class BatchExecutionLogService {
batchConfigId?: number,
startDate?: Date,
endDate?: Date
): Promise<ApiResponse<{
total_executions: number;
success_count: number;
failed_count: number;
success_rate: number;
average_duration_ms: number;
total_records_processed: number;
}>> {
): Promise<
ApiResponse<{
total_executions: number;
success_count: number;
failed_count: number;
success_rate: number;
average_duration_ms: number;
total_records_processed: number;
}>
> {
try {
const where: any = {};
const whereConditions: string[] = [];
const params: any[] = [];
let paramIndex = 1;
if (batchConfigId) {
where.batch_config_id = batchConfigId;
}
if (startDate || endDate) {
where.start_time = {};
if (startDate) {
where.start_time.gte = startDate;
}
if (endDate) {
where.start_time.lte = endDate;
}
whereConditions.push(`batch_config_id = $${paramIndex++}`);
params.push(batchConfigId);
}
const logs = await prisma.batch_execution_logs.findMany({
where,
select: {
execution_status: true,
duration_ms: true,
total_records: true
}
});
if (startDate) {
whereConditions.push(`start_time >= $${paramIndex++}`);
params.push(startDate);
}
if (endDate) {
whereConditions.push(`start_time <= $${paramIndex++}`);
params.push(endDate);
}
const whereClause =
whereConditions.length > 0
? `WHERE ${whereConditions.join(" AND ")}`
: "";
const logs = await query<{
execution_status: string;
duration_ms: number;
total_records: number;
}>(
`SELECT execution_status, duration_ms, total_records
FROM batch_execution_logs
${whereClause}`,
params
);
const total_executions = logs.length;
const success_count = logs.filter((log: any) => log.execution_status === 'SUCCESS').length;
const failed_count = logs.filter((log: any) => log.execution_status === 'FAILED').length;
const success_rate = total_executions > 0 ? (success_count / total_executions) * 100 : 0;
const success_count = logs.filter(
(log: any) => log.execution_status === "SUCCESS"
).length;
const failed_count = logs.filter(
(log: any) => log.execution_status === "FAILED"
).length;
const success_rate =
total_executions > 0 ? (success_count / total_executions) * 100 : 0;
const validDurations = logs
.filter((log: any) => log.duration_ms !== null)
.map((log: any) => log.duration_ms!);
const average_duration_ms = validDurations.length > 0
? validDurations.reduce((sum: number, duration: number) => sum + duration, 0) / validDurations.length
: 0;
const average_duration_ms =
validDurations.length > 0
? validDurations.reduce(
(sum: number, duration: number) => sum + duration,
0
) / validDurations.length
: 0;
const total_records_processed = logs
.filter((log: any) => log.total_records !== null)
.reduce((sum: number, log: any) => sum + (log.total_records || 0), 0);
@ -284,15 +366,15 @@ export class BatchExecutionLogService {
failed_count,
success_rate,
average_duration_ms,
total_records_processed
}
total_records_processed,
},
};
} catch (error) {
console.error("배치 실행 통계 조회 실패:", error);
return {
success: false,
message: "배치 실행 통계 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}

714
backend-node/src/services/batchExternalDbService.ts
View File

File diff suppressed because it is too large Load Diff

280
backend-node/src/services/batchManagementService.ts
View File

@ -1,13 +1,13 @@
// 배치관리 전용 서비스 (기존 소스와 완전 분리)
// 작성일: 2024-12-24
import prisma from "../config/database";
import { query, queryOne } from "../database/db";
import { PasswordEncryption } from "../utils/passwordEncryption";
import { DatabaseConnectorFactory } from "../database/DatabaseConnectorFactory";
// 배치관리 전용 타입 정의
export interface BatchConnectionInfo {
type: 'internal' | 'external';
type: "internal" | "external";
id?: number;
name: string;
db_type?: string;
@ -37,50 +37,54 @@ export class BatchManagementService {
/**
* 배치관리용 연결 목록 조회
*/
static async getAvailableConnections(): Promise<BatchApiResponse<BatchConnectionInfo[]>> {
static async getAvailableConnections(): Promise<
BatchApiResponse<BatchConnectionInfo[]>
> {
try {
const connections: BatchConnectionInfo[] = [];
// 내부 DB 추가
connections.push({
type: 'internal',
name: '내부 데이터베이스 (PostgreSQL)',
db_type: 'postgresql'
type: "internal",
name: "내부 데이터베이스 (PostgreSQL)",
db_type: "postgresql",
});
// 활성화된 외부 DB 연결 조회
const externalConnections = await prisma.external_db_connections.findMany({
where: { is_active: 'Y' },
select: {
id: true,
connection_name: true,
db_type: true,
description: true
},
orderBy: { connection_name: 'asc' }
});
const externalConnections = await query<{
id: number;
connection_name: string;
db_type: string;
description: string;
}>(
`SELECT id, connection_name, db_type, description
FROM external_db_connections
WHERE is_active = 'Y'
ORDER BY connection_name ASC`,
[]
);
// 외부 DB 연결 추가
externalConnections.forEach(conn => {
externalConnections.forEach((conn) => {
connections.push({
type: 'external',
type: "external",
id: conn.id,
name: `${conn.connection_name} (${conn.db_type?.toUpperCase()})`,
db_type: conn.db_type || undefined
db_type: conn.db_type || undefined,
});
});
return {
success: true,
data: connections,
message: `${connections.length}개의 연결을 조회했습니다.`
message: `${connections.length}개의 연결을 조회했습니다.`,
};
} catch (error) {
console.error("배치관리 연결 목록 조회 실패:", error);
return {
success: false,
message: "연결 목록 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -89,27 +93,28 @@ export class BatchManagementService {
* 배치관리용 테이블 목록 조회
*/
static async getTablesFromConnection(
connectionType: 'internal' | 'external',
connectionType: "internal" | "external",
connectionId?: number
): Promise<BatchApiResponse<BatchTableInfo[]>> {
try {
let tables: BatchTableInfo[] = [];
if (connectionType === 'internal') {
if (connectionType === "internal") {
// 내부 DB 테이블 조회
const result = await prisma.$queryRaw<Array<{ table_name: string }>>`
SELECT table_name
const result = await query<{ table_name: string }>(
`SELECT table_name
FROM information_schema.tables
WHERE table_schema = 'public'
AND table_type = 'BASE TABLE'
ORDER BY table_name
`;
ORDER BY table_name`,
[]
);
tables = result.map(row => ({
tables = result.map((row) => ({
table_name: row.table_name,
columns: []
columns: [],
}));
} else if (connectionType === 'external' && connectionId) {
} else if (connectionType === "external" && connectionId) {
// 외부 DB 테이블 조회
const tablesResult = await this.getExternalTables(connectionId);
if (tablesResult.success && tablesResult.data) {
@ -120,14 +125,14 @@ export class BatchManagementService {
return {
success: true,
data: tables,
message: `${tables.length}개의 테이블을 조회했습니다.`
message: `${tables.length}개의 테이블을 조회했습니다.`,
};
} catch (error) {
console.error("배치관리 테이블 목록 조회 실패:", error);
return {
success: false,
message: "테이블 목록 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -136,7 +141,7 @@ export class BatchManagementService {
* 배치관리용 테이블 컬럼 정보 조회
*/
static async getTableColumns(
connectionType: 'internal' | 'external',
connectionType: "internal" | "external",
connectionId: number | undefined,
tableName: string
): Promise<BatchApiResponse<BatchColumnInfo[]>> {
@ -144,49 +149,60 @@ export class BatchManagementService {
console.log(`[BatchManagementService] getTableColumns 호출:`, {
connectionType,
connectionId,
tableName
tableName,
});
let columns: BatchColumnInfo[] = [];
if (connectionType === 'internal') {
if (connectionType === "internal") {
// 내부 DB 컬럼 조회
console.log(`[BatchManagementService] 내부 DB 컬럼 조회 시작: ${tableName}`);
console.log(
`[BatchManagementService] 내부 DB 컬럼 조회 시작: ${tableName}`
);
const result = await prisma.$queryRaw<Array<{
column_name: string;
data_type: string;
is_nullable: string;
column_default: string | null
}>>`
SELECT
const result = await query<{
column_name: string;
data_type: string;
is_nullable: string;
column_default: string | null;
}>(
`SELECT
column_name,
data_type,
is_nullable,
column_default
FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = ${tableName}
ORDER BY ordinal_position
`;
AND table_name = $1
ORDER BY ordinal_position`,
[tableName]
);
console.log(`[BatchManagementService] 쿼리 결과:`, result);
console.log(`[BatchManagementService] 내부 DB 컬럼 조회 결과:`, result);
columns = result.map(row => ({
columns = result.map((row) => ({
column_name: row.column_name,
data_type: row.data_type,
is_nullable: row.is_nullable,
column_default: row.column_default,
}));
} else if (connectionType === 'external' && connectionId) {
} else if (connectionType === "external" && connectionId) {
// 외부 DB 컬럼 조회
console.log(`[BatchManagementService] 외부 DB 컬럼 조회 시작: connectionId=${connectionId}, tableName=${tableName}`);
console.log(
`[BatchManagementService] 외부 DB 컬럼 조회 시작: connectionId=${connectionId}, tableName=${tableName}`
);
const columnsResult = await this.getExternalTableColumns(connectionId, tableName);
console.log(`[BatchManagementService] 외부 DB 컬럼 조회 결과:`, columnsResult);
const columnsResult = await this.getExternalTableColumns(
connectionId,
tableName
);
console.log(
`[BatchManagementService] 외부 DB 컬럼 조회 결과:`,
columnsResult
);
if (columnsResult.success && columnsResult.data) {
columns = columnsResult.data;
@ -197,14 +213,14 @@ export class BatchManagementService {
return {
success: true,
data: columns,
message: `${columns.length}개의 컬럼을 조회했습니다.`
message: `${columns.length}개의 컬럼을 조회했습니다.`,
};
} catch (error) {
console.error("[BatchManagementService] 컬럼 정보 조회 오류:", error);
return {
success: false,
message: "컬럼 정보 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -212,17 +228,20 @@ export class BatchManagementService {
/**
* 외부 DB 테이블 목록 조회 (내부 구현)
*/
private static async getExternalTables(connectionId: number): Promise<BatchApiResponse<BatchTableInfo[]>> {
private static async getExternalTables(
connectionId: number
): Promise<BatchApiResponse<BatchTableInfo[]>> {
try {
// 연결 정보 조회
const connection = await prisma.external_db_connections.findUnique({
where: { id: connectionId }
});
const connection = await queryOne<any>(
`SELECT * FROM external_db_connections WHERE id = $1`,
[connectionId]
);
if (!connection) {
return {
success: false,
message: "연결 정보를 찾을 수 없습니다."
message: "연결 정보를 찾을 수 없습니다.",
};
}
@ -231,7 +250,7 @@ export class BatchManagementService {
if (!decryptedPassword) {
return {
success: false,
message: "비밀번호 복호화에 실패했습니다."
message: "비밀번호 복호화에 실패했습니다.",
};
}
@ -242,26 +261,39 @@ export class BatchManagementService {
database: connection.database_name,
user: connection.username,
password: decryptedPassword,
connectionTimeoutMillis: connection.connection_timeout != null ? connection.connection_timeout * 1000 : undefined,
queryTimeoutMillis: connection.query_timeout != null ? connection.query_timeout * 1000 : undefined,
ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false
connectionTimeoutMillis:
connection.connection_timeout != null
? connection.connection_timeout * 1000
: undefined,
queryTimeoutMillis:
connection.query_timeout != null
? connection.query_timeout * 1000
: undefined,
ssl:
connection.ssl_enabled === "Y"
? { rejectUnauthorized: false }
: false,
};
// DatabaseConnectorFactory를 통한 테이블 목록 조회
const connector = await DatabaseConnectorFactory.createConnector(connection.db_type, config, connectionId);
const connector = await DatabaseConnectorFactory.createConnector(
connection.db_type,
config,
connectionId
);
const tables = await connector.getTables();
return {
success: true,
message: "테이블 목록을 조회했습니다.",
data: tables
data: tables,
};
} catch (error) {
console.error("외부 DB 테이블 목록 조회 오류:", error);
return {
success: false,
message: "테이블 목록 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -269,20 +301,28 @@ export class BatchManagementService {
/**
* 외부 DB 테이블 컬럼 정보 조회 (내부 구현)
*/
private static async getExternalTableColumns(connectionId: number, tableName: string): Promise<BatchApiResponse<BatchColumnInfo[]>> {
private static async getExternalTableColumns(
connectionId: number,
tableName: string
): Promise<BatchApiResponse<BatchColumnInfo[]>> {
try {
console.log(`[BatchManagementService] getExternalTableColumns 호출: connectionId=${connectionId}, tableName=${tableName}`);
console.log(
`[BatchManagementService] getExternalTableColumns 호출: connectionId=${connectionId}, tableName=${tableName}`
);
// 연결 정보 조회
const connection = await prisma.external_db_connections.findUnique({
where: { id: connectionId }
});
const connection = await queryOne<any>(
`SELECT * FROM external_db_connections WHERE id = $1`,
[connectionId]
);
if (!connection) {
console.log(`[BatchManagementService] 연결 정보를 찾을 수 없음: connectionId=${connectionId}`);
console.log(
`[BatchManagementService] 연결 정보를 찾을 수 없음: connectionId=${connectionId}`
);
return {
success: false,
message: "연결 정보를 찾을 수 없습니다."
message: "연결 정보를 찾을 수 없습니다.",
};
}
@ -292,12 +332,12 @@ export class BatchManagementService {
db_type: connection.db_type,
host: connection.host,
port: connection.port,
database_name: connection.database_name
database_name: connection.database_name,
});
// 비밀번호 복호화
const decryptedPassword = PasswordEncryption.decrypt(connection.password);
// 연결 설정 준비
const config = {
host: connection.host,
@ -305,38 +345,61 @@ export class BatchManagementService {
database: connection.database_name,
user: connection.username,
password: decryptedPassword,
connectionTimeoutMillis: connection.connection_timeout != null ? connection.connection_timeout * 1000 : undefined,
queryTimeoutMillis: connection.query_timeout != null ? connection.query_timeout * 1000 : undefined,
ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false
connectionTimeoutMillis:
connection.connection_timeout != null
? connection.connection_timeout * 1000
: undefined,
queryTimeoutMillis:
connection.query_timeout != null
? connection.query_timeout * 1000
: undefined,
ssl:
connection.ssl_enabled === "Y"
? { rejectUnauthorized: false }
: false,
};
console.log(`[BatchManagementService] 커넥터 생성 시작: db_type=${connection.db_type}`);
console.log(
`[BatchManagementService] 커넥터 생성 시작: db_type=${connection.db_type}`
);
// 데이터베이스 타입에 따른 커넥터 생성
const connector = await DatabaseConnectorFactory.createConnector(connection.db_type, config, connectionId);
console.log(`[BatchManagementService] 커넥터 생성 완료, 컬럼 조회 시작: tableName=${tableName}`);
const connector = await DatabaseConnectorFactory.createConnector(
connection.db_type,
config,
connectionId
);
console.log(
`[BatchManagementService] 커넥터 생성 완료, 컬럼 조회 시작: tableName=${tableName}`
);
// 컬럼 정보 조회
console.log(`[BatchManagementService] connector.getColumns 호출 전`);
const columns = await connector.getColumns(tableName);
console.log(`[BatchManagementService] 원본 컬럼 조회 결과:`, columns);
console.log(`[BatchManagementService] 원본 컬럼 개수:`, columns ? columns.length : 'null/undefined');
console.log(
`[BatchManagementService] 원본 컬럼 개수:`,
columns ? columns.length : "null/undefined"
);
// 각 데이터베이스 커넥터의 반환 구조가 다르므로 통일된 구조로 변환
const standardizedColumns: BatchColumnInfo[] = columns.map((col: any) => {
console.log(`[BatchManagementService] 컬럼 변환 중:`, col);
// MySQL/MariaDB 구조: {name, dataType, isNullable, defaultValue} (MySQLConnector만)
if (col.name && col.dataType !== undefined) {
const result = {
column_name: col.name,
data_type: col.dataType,
is_nullable: col.isNullable ? 'YES' : 'NO',
is_nullable: col.isNullable ? "YES" : "NO",
column_default: col.defaultValue || null,
};
console.log(`[BatchManagementService] MySQL/MariaDB 구조로 변환:`, result);
console.log(
`[BatchManagementService] MySQL/MariaDB 구조로 변환:`,
result
);
return result;
}
// PostgreSQL/Oracle/MSSQL/MariaDB 구조: {column_name, data_type, is_nullable, column_default}
@ -344,30 +407,41 @@ export class BatchManagementService {
const result = {
column_name: col.column_name || col.COLUMN_NAME,
data_type: col.data_type || col.DATA_TYPE,
is_nullable: col.is_nullable || col.IS_NULLABLE || (col.nullable === 'Y' ? 'YES' : 'NO'),
is_nullable:
col.is_nullable ||
col.IS_NULLABLE ||
(col.nullable === "Y" ? "YES" : "NO"),
column_default: col.column_default || col.COLUMN_DEFAULT || null,
};
console.log(`[BatchManagementService] 표준 구조로 변환:`, result);
return result;
}
});
console.log(`[BatchManagementService] 표준화된 컬럼 목록:`, standardizedColumns);
console.log(
`[BatchManagementService] 표준화된 컬럼 목록:`,
standardizedColumns
);
return {
success: true,
data: standardizedColumns,
message: "컬럼 정보를 조회했습니다."
message: "컬럼 정보를 조회했습니다.",
};
} catch (error) {
console.error("[BatchManagementService] 외부 DB 컬럼 정보 조회 오류:", error);
console.error("[BatchManagementService] 오류 스택:", error instanceof Error ? error.stack : 'No stack trace');
console.error(
"[BatchManagementService] 외부 DB 컬럼 정보 조회 오류:",
error
);
console.error(
"[BatchManagementService] 오류 스택:",
error instanceof Error ? error.stack : "No stack trace"
);
return {
success: false,
message: "컬럼 정보 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
}

377
backend-node/src/services/batchSchedulerService.ts
View File

@ -1,11 +1,11 @@
// 배치 스케줄러 서비스
// 작성일: 2024-12-24
import * as cron from 'node-cron';
import prisma from '../config/database';
import { BatchService } from './batchService';
import { BatchExecutionLogService } from './batchExecutionLogService';
import { logger } from '../utils/logger';
import * as cron from "node-cron";
import { query, queryOne } from "../database/db";
import { BatchService } from "./batchService";
import { BatchExecutionLogService } from "./batchExecutionLogService";
import { logger } from "../utils/logger";
export class BatchSchedulerService {
private static scheduledTasks: Map<number, cron.ScheduledTask> = new Map();
@ -17,18 +17,18 @@ export class BatchSchedulerService {
*/
static async initialize() {
try {
logger.info('배치 스케줄러 초기화 시작...');
logger.info("배치 스케줄러 초기화 시작...");
// 기존 모든 스케줄 정리 (중복 방지)
this.clearAllSchedules();
// 활성화된 배치 설정들을 로드하여 스케줄 등록
await this.loadActiveBatchConfigs();
this.isInitialized = true;
logger.info('배치 스케줄러 초기화 완료');
logger.info("배치 스케줄러 초기화 완료");
} catch (error) {
logger.error('배치 스케줄러 초기화 실패:', error);
logger.error("배치 스케줄러 초기화 실패:", error);
throw error;
}
}
@ -38,7 +38,7 @@ export class BatchSchedulerService {
*/
private static clearAllSchedules() {
logger.info(`기존 스케줄 ${this.scheduledTasks.size}개 정리 중...`);
for (const [id, task] of this.scheduledTasks) {
try {
task.stop();
@ -48,10 +48,10 @@ export class BatchSchedulerService {
logger.error(`스케줄 정리 실패: ID ${id}`, error);
}
}
this.scheduledTasks.clear();
this.isInitialized = false;
logger.info('모든 스케줄 정리 완료');
logger.info("모든 스케줄 정리 완료");
}
/**
@ -59,14 +59,43 @@ export class BatchSchedulerService {
*/
private static async loadActiveBatchConfigs() {
try {
const activeConfigs = await prisma.batch_configs.findMany({
where: {
is_active: 'Y'
},
include: {
batch_mappings: true
}
});
const activeConfigs = await query<any>(
`SELECT
bc.*,
json_agg(
json_build_object(
'id', bm.id,
'batch_config_id', bm.batch_config_id,
'from_connection_type', bm.from_connection_type,
'from_connection_id', bm.from_connection_id,
'from_table_name', bm.from_table_name,
'from_column_name', bm.from_column_name,
'from_column_type', bm.from_column_type,
'to_connection_type', bm.to_connection_type,
'to_connection_id', bm.to_connection_id,
'to_table_name', bm.to_table_name,
'to_column_name', bm.to_column_name,
'to_column_type', bm.to_column_type,
'mapping_order', bm.mapping_order,
'from_api_url', bm.from_api_url,
'from_api_key', bm.from_api_key,
'from_api_method', bm.from_api_method,
'from_api_param_type', bm.from_api_param_type,
'from_api_param_name', bm.from_api_param_name,
'from_api_param_value', bm.from_api_param_value,
'from_api_param_source', bm.from_api_param_source,
'to_api_url', bm.to_api_url,
'to_api_key', bm.to_api_key,
'to_api_method', bm.to_api_method,
'to_api_body', bm.to_api_body
)
) FILTER (WHERE bm.id IS NOT NULL) as batch_mappings
FROM batch_configs bc
LEFT JOIN batch_mappings bm ON bc.id = bm.batch_config_id
WHERE bc.is_active = 'Y'
GROUP BY bc.id`,
[]
);
logger.info(`활성화된 배치 설정 ${activeConfigs.length}개 발견`);
@ -74,7 +103,7 @@ export class BatchSchedulerService {
await this.scheduleBatchConfig(config);
}
} catch (error) {
logger.error('활성화된 배치 설정 로드 실패:', error);
logger.error("활성화된 배치 설정 로드 실패:", error);
throw error;
}
}
@ -102,15 +131,17 @@ export class BatchSchedulerService {
const task = cron.schedule(cron_schedule, async () => {
// 중복 실행 방지 체크
if (this.executingBatches.has(id)) {
logger.warn(`⚠️ 배치가 이미 실행 중입니다. 건너뜀: ${batch_name} (ID: ${id})`);
logger.warn(
`⚠️ 배치가 이미 실행 중입니다. 건너뜀: ${batch_name} (ID: ${id})`
);
return;
}
logger.info(`🔄 스케줄 배치 실행 시작: ${batch_name} (ID: ${id})`);
// 실행 중 플래그 설정
this.executingBatches.add(id);
try {
await this.executeBatchConfig(config);
} finally {
@ -121,9 +152,11 @@ export class BatchSchedulerService {
// 스케줄 시작 (기본적으로 시작되지만 명시적으로 호출)
task.start();
this.scheduledTasks.set(id, task);
logger.info(`배치 스케줄 등록 완료: ${batch_name} (ID: ${id}, Schedule: ${cron_schedule}) - 스케줄 시작됨`);
logger.info(
`배치 스케줄 등록 완료: ${batch_name} (ID: ${id}, Schedule: ${cron_schedule}) - 스케줄 시작됨`
);
} catch (error) {
logger.error(`배치 스케줄 등록 실패 (ID: ${config.id}):`, error);
}
@ -147,16 +180,54 @@ export class BatchSchedulerService {
/**
* 배치 설정 업데이트 시 스케줄 재등록
*/
static async updateBatchSchedule(configId: number, executeImmediately: boolean = true) {
static async updateBatchSchedule(
configId: number,
executeImmediately: boolean = true
) {
try {
// 기존 스케줄 제거
await this.unscheduleBatchConfig(configId);
// 업데이트된 배치 설정 조회
const config = await prisma.batch_configs.findUnique({
where: { id: configId },
include: { batch_mappings: true }
});
const configResult = await query<any>(
`SELECT
bc.*,
json_agg(
json_build_object(
'id', bm.id,
'batch_config_id', bm.batch_config_id,
'from_connection_type', bm.from_connection_type,
'from_connection_id', bm.from_connection_id,
'from_table_name', bm.from_table_name,
'from_column_name', bm.from_column_name,
'from_column_type', bm.from_column_type,
'to_connection_type', bm.to_connection_type,
'to_connection_id', bm.to_connection_id,
'to_table_name', bm.to_table_name,
'to_column_name', bm.to_column_name,
'to_column_type', bm.to_column_type,
'mapping_order', bm.mapping_order,
'from_api_url', bm.from_api_url,
'from_api_key', bm.from_api_key,
'from_api_method', bm.from_api_method,
'from_api_param_type', bm.from_api_param_type,
'from_api_param_name', bm.from_api_param_name,
'from_api_param_value', bm.from_api_param_value,
'from_api_param_source', bm.from_api_param_source,
'to_api_url', bm.to_api_url,
'to_api_key', bm.to_api_key,
'to_api_method', bm.to_api_method,
'to_api_body', bm.to_api_body
)
) FILTER (WHERE bm.id IS NOT NULL) as batch_mappings
FROM batch_configs bc
LEFT JOIN batch_mappings bm ON bc.id = bm.batch_config_id
WHERE bc.id = $1
GROUP BY bc.id`,
[configId]
);
const config = configResult[0] || null;
if (!config) {
logger.warn(`배치 설정을 찾을 수 없습니다: ID ${configId}`);
@ -164,17 +235,23 @@ export class BatchSchedulerService {
}
// 활성화된 배치만 다시 스케줄 등록
if (config.is_active === 'Y') {
if (config.is_active === "Y") {
await this.scheduleBatchConfig(config);
logger.info(`배치 스케줄 업데이트 완료: ${config.batch_name} (ID: ${configId})`);
logger.info(
`배치 스케줄 업데이트 완료: ${config.batch_name} (ID: ${configId})`
);
// 활성화 시 즉시 실행 (옵션)
if (executeImmediately) {
logger.info(`🚀 배치 활성화 즉시 실행: ${config.batch_name} (ID: ${configId})`);
logger.info(
`🚀 배치 활성화 즉시 실행: ${config.batch_name} (ID: ${configId})`
);
await this.executeBatchConfig(config);
}
} else {
logger.info(`비활성화된 배치 스케줄 제거: ${config.batch_name} (ID: ${configId})`);
logger.info(
`비활성화된 배치 스케줄 제거: ${config.batch_name} (ID: ${configId})`
);
}
} catch (error) {
logger.error(`배치 스케줄 업데이트 실패: ID ${configId}`, error);
@ -192,21 +269,25 @@ export class BatchSchedulerService {
logger.info(`배치 실행 시작: ${config.batch_name} (ID: ${config.id})`);
// 실행 로그 생성
const executionLogResponse = await BatchExecutionLogService.createExecutionLog({
batch_config_id: config.id,
execution_status: 'RUNNING',
start_time: startTime,
total_records: 0,
success_records: 0,
failed_records: 0
});
const executionLogResponse =
await BatchExecutionLogService.createExecutionLog({
batch_config_id: config.id,
execution_status: "RUNNING",
start_time: startTime,
total_records: 0,
success_records: 0,
failed_records: 0,
});
if (!executionLogResponse.success || !executionLogResponse.data) {
logger.error(`배치 실행 로그 생성 실패: ${config.batch_name}`, executionLogResponse.message);
logger.error(
`배치 실행 로그 생성 실패: ${config.batch_name}`,
executionLogResponse.message
);
return {
totalRecords: 0,
successRecords: 0,
failedRecords: 1
failedRecords: 1,
};
}
@ -217,38 +298,40 @@ export class BatchSchedulerService {
// 실행 로그 업데이트 (성공)
await BatchExecutionLogService.updateExecutionLog(executionLog.id, {
execution_status: 'SUCCESS',
execution_status: "SUCCESS",
end_time: new Date(),
duration_ms: Date.now() - startTime.getTime(),
total_records: result.totalRecords,
success_records: result.successRecords,
failed_records: result.failedRecords
failed_records: result.failedRecords,
});
logger.info(`배치 실행 완료: ${config.batch_name} (처리된 레코드: ${result.totalRecords})`);
logger.info(
`배치 실행 완료: ${config.batch_name} (처리된 레코드: ${result.totalRecords})`
);
// 성공 결과 반환
return result;
} catch (error) {
logger.error(`배치 실행 실패: ${config.batch_name}`, error);
// 실행 로그 업데이트 (실패)
if (executionLog) {
await BatchExecutionLogService.updateExecutionLog(executionLog.id, {
execution_status: 'FAILED',
execution_status: "FAILED",
end_time: new Date(),
duration_ms: Date.now() - startTime.getTime(),
error_message: error instanceof Error ? error.message : '알 수 없는 오류',
error_details: error instanceof Error ? error.stack : String(error)
error_message:
error instanceof Error ? error.message : "알 수 없는 오류",
error_details: error instanceof Error ? error.stack : String(error),
});
}
// 실패 시에도 결과 반환
return {
totalRecords: 0,
successRecords: 0,
failedRecords: 1
failedRecords: 1,
};
}
}
@ -268,9 +351,9 @@ export class BatchSchedulerService {
// 테이블별로 매핑을 그룹화
const tableGroups = new Map<string, typeof config.batch_mappings>();
for (const mapping of config.batch_mappings) {
const key = `${mapping.from_connection_type}:${mapping.from_connection_id || 'internal'}:${mapping.from_table_name}`;
const key = `${mapping.from_connection_type}:${mapping.from_connection_id || "internal"}:${mapping.from_table_name}`;
if (!tableGroups.has(key)) {
tableGroups.set(key, []);
}
@ -281,20 +364,30 @@ export class BatchSchedulerService {
for (const [tableKey, mappings] of tableGroups) {
try {
const firstMapping = mappings[0];
logger.info(`테이블 처리 시작: ${tableKey} -> ${mappings.length}개 컬럼 매핑`);
logger.info(
`테이블 처리 시작: ${tableKey} -> ${mappings.length}개 컬럼 매핑`
);
let fromData: any[] = [];
// FROM 데이터 조회 (DB 또는 REST API)
if (firstMapping.from_connection_type === 'restapi') {
if (firstMapping.from_connection_type === "restapi") {
// REST API에서 데이터 조회
logger.info(`REST API에서 데이터 조회: ${firstMapping.from_api_url}${firstMapping.from_table_name}`);
const { BatchExternalDbService } = await import('./batchExternalDbService');
logger.info(
`REST API에서 데이터 조회: ${firstMapping.from_api_url}${firstMapping.from_table_name}`
);
const { BatchExternalDbService } = await import(
"./batchExternalDbService"
);
const apiResult = await BatchExternalDbService.getDataFromRestApi(
firstMapping.from_api_url!,
firstMapping.from_api_key!,
firstMapping.from_table_name,
firstMapping.from_api_method as 'GET' | 'POST' | 'PUT' | 'DELETE' || 'GET',
(firstMapping.from_api_method as
| "GET"
| "POST"
| "PUT"
| "DELETE") || "GET",
mappings.map((m: any) => m.from_column_name),
100, // limit
// 파라미터 정보 전달
@ -303,7 +396,7 @@ export class BatchSchedulerService {
firstMapping.from_api_param_value,
firstMapping.from_api_param_source
);
if (apiResult.success && apiResult.data) {
fromData = apiResult.data;
} else {
@ -315,21 +408,25 @@ export class BatchSchedulerService {
fromData = await BatchService.getDataFromTableWithColumns(
firstMapping.from_table_name,
fromColumns,
firstMapping.from_connection_type as 'internal' | 'external',
firstMapping.from_connection_type as "internal" | "external",
firstMapping.from_connection_id || undefined
);
}
totalRecords += fromData.length;
// 컬럼 매핑 적용하여 TO 테이블 형식으로 변환
const mappedData = fromData.map(row => {
const mappedData = fromData.map((row) => {
const mappedRow: any = {};
for (const mapping of mappings) {
// DB → REST API 배치인지 확인
if (firstMapping.to_connection_type === 'restapi' && mapping.to_api_body) {
if (
firstMapping.to_connection_type === "restapi" &&
mapping.to_api_body
) {
// DB → REST API: 원본 컬럼명을 키로 사용 (템플릿 처리용)
mappedRow[mapping.from_column_name] = row[mapping.from_column_name];
mappedRow[mapping.from_column_name] =
row[mapping.from_column_name];
} else {
// 기존 로직: to_column_name을 키로 사용
mappedRow[mapping.to_column_name] = row[mapping.from_column_name];
@ -340,37 +437,49 @@ export class BatchSchedulerService {
// TO 테이블에 데이터 삽입 (DB 또는 REST API)
let insertResult: { successCount: number; failedCount: number };
if (firstMapping.to_connection_type === 'restapi') {
if (firstMapping.to_connection_type === "restapi") {
// REST API로 데이터 전송
logger.info(`REST API로 데이터 전송: ${firstMapping.to_api_url}${firstMapping.to_table_name}`);
const { BatchExternalDbService } = await import('./batchExternalDbService');
logger.info(
`REST API로 데이터 전송: ${firstMapping.to_api_url}${firstMapping.to_table_name}`
);
const { BatchExternalDbService } = await import(
"./batchExternalDbService"
);
// DB → REST API 배치인지 확인 (to_api_body가 있으면 템플릿 기반)
const hasTemplate = mappings.some((m: any) => m.to_api_body);
if (hasTemplate) {
// 템플릿 기반 REST API 전송 (DB → REST API 배치)
const templateBody = firstMapping.to_api_body || '{}';
logger.info(`템플릿 기반 REST API 전송, Request Body 템플릿: ${templateBody}`);
// URL 경로 컬럼 찾기 (PUT/DELETE용)
const urlPathColumn = mappings.find((m: any) => m.to_column_name === 'URL_PATH_PARAM')?.from_column_name;
const apiResult = await BatchExternalDbService.sendDataToRestApiWithTemplate(
firstMapping.to_api_url!,
firstMapping.to_api_key!,
firstMapping.to_table_name,
firstMapping.to_api_method as 'POST' | 'PUT' | 'DELETE' || 'POST',
templateBody,
mappedData,
urlPathColumn
);
const templateBody = firstMapping.to_api_body || "{}";
logger.info(
`템플릿 기반 REST API 전송, Request Body 템플릿: ${templateBody}`
);
// URL 경로 컬럼 찾기 (PUT/DELETE용)
const urlPathColumn = mappings.find(
(m: any) => m.to_column_name === "URL_PATH_PARAM"
)?.from_column_name;
const apiResult =
await BatchExternalDbService.sendDataToRestApiWithTemplate(
firstMapping.to_api_url!,
firstMapping.to_api_key!,
firstMapping.to_table_name,
(firstMapping.to_api_method as "POST" | "PUT" | "DELETE") ||
"POST",
templateBody,
mappedData,
urlPathColumn
);
if (apiResult.success && apiResult.data) {
insertResult = apiResult.data;
} else {
throw new Error(`템플릿 기반 REST API 데이터 전송 실패: ${apiResult.message}`);
throw new Error(
`템플릿 기반 REST API 데이터 전송 실패: ${apiResult.message}`
);
}
} else {
// 기존 REST API 전송 (REST API → DB 배치)
@ -378,14 +487,16 @@ export class BatchSchedulerService {
firstMapping.to_api_url!,
firstMapping.to_api_key!,
firstMapping.to_table_name,
firstMapping.to_api_method as 'POST' | 'PUT' || 'POST',
(firstMapping.to_api_method as "POST" | "PUT") || "POST",
mappedData
);
if (apiResult.success && apiResult.data) {
insertResult = apiResult.data;
} else {
throw new Error(`REST API 데이터 전송 실패: ${apiResult.message}`);
throw new Error(
`REST API 데이터 전송 실패: ${apiResult.message}`
);
}
}
} else {
@ -393,15 +504,17 @@ export class BatchSchedulerService {
insertResult = await BatchService.insertDataToTable(
firstMapping.to_table_name,
mappedData,
firstMapping.to_connection_type as 'internal' | 'external',
firstMapping.to_connection_type as "internal" | "external",
firstMapping.to_connection_id || undefined
);
}
successRecords += insertResult.successCount;
failedRecords += insertResult.failedCount;
logger.info(`테이블 처리 완료: ${insertResult.successCount}개 성공, ${insertResult.failedCount}개 실패`);
logger.info(
`테이블 처리 완료: ${insertResult.successCount}개 성공, ${insertResult.failedCount}개 실패`
);
} catch (error) {
logger.error(`테이블 처리 실패: ${tableKey}`, error);
failedRecords += 1;
@ -427,7 +540,9 @@ export class BatchSchedulerService {
for (const mapping of batch_mappings) {
try {
logger.info(`매핑 처리 시작: ${mapping.from_table_name} -> ${mapping.to_table_name}`);
logger.info(
`매핑 처리 시작: ${mapping.from_table_name} -> ${mapping.to_table_name}`
);
// FROM 테이블에서 데이터 조회
const fromData = await this.getDataFromSource(mapping);
@ -438,9 +553,14 @@ export class BatchSchedulerService {
successRecords += insertResult.successCount;
failedRecords += insertResult.failedCount;
logger.info(`매핑 처리 완료: ${insertResult.successCount}개 성공, ${insertResult.failedCount}개 실패`);
logger.info(
`매핑 처리 완료: ${insertResult.successCount}개 성공, ${insertResult.failedCount}개 실패`
);
} catch (error) {
logger.error(`매핑 처리 실패: ${mapping.from_table_name} -> ${mapping.to_table_name}`, error);
logger.error(
`매핑 처리 실패: ${mapping.from_table_name} -> ${mapping.to_table_name}`,
error
);
failedRecords += 1;
}
}
@ -453,19 +573,23 @@ export class BatchSchedulerService {
*/
private static async getDataFromSource(mapping: any) {
try {
if (mapping.from_connection_type === 'internal') {
if (mapping.from_connection_type === "internal") {
// 내부 DB에서 조회
const result = await prisma.$queryRawUnsafe(
`SELECT * FROM ${mapping.from_table_name}`
const result = await query<any>(
`SELECT * FROM ${mapping.from_table_name}`,
[]
);
return result as any[];
return result;
} else {
// 외부 DB에서 조회 (구현 필요)
logger.warn('외부 DB 조회는 아직 구현되지 않았습니다.');
logger.warn("외부 DB 조회는 아직 구현되지 않았습니다.");
return [];
}
} catch (error) {
logger.error(`FROM 테이블 데이터 조회 실패: ${mapping.from_table_name}`, error);
logger.error(
`FROM 테이블 데이터 조회 실패: ${mapping.from_table_name}`,
error
);
throw error;
}
}
@ -478,16 +602,20 @@ export class BatchSchedulerService {
let failedCount = 0;
try {
if (mapping.to_connection_type === 'internal') {
if (mapping.to_connection_type === "internal") {
// 내부 DB에 삽입
for (const record of data) {
try {
// 매핑된 컬럼만 추출
const mappedData = this.mapColumns(record, mapping);
await prisma.$executeRawUnsafe(
`INSERT INTO ${mapping.to_table_name} (${Object.keys(mappedData).join(', ')}) VALUES (${Object.values(mappedData).map(() => '?').join(', ')})`,
...Object.values(mappedData)
const columns = Object.keys(mappedData);
const values = Object.values(mappedData);
const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
await query(
`INSERT INTO ${mapping.to_table_name} (${columns.join(", ")}) VALUES (${placeholders})`,
values
);
successCount++;
} catch (error) {
@ -497,11 +625,14 @@ export class BatchSchedulerService {
}
} else {
// 외부 DB에 삽입 (구현 필요)
logger.warn('외부 DB 삽입은 아직 구현되지 않았습니다.');
logger.warn("외부 DB 삽입은 아직 구현되지 않았습니다.");
failedCount = data.length;
}
} catch (error) {
logger.error(`TO 테이블 데이터 삽입 실패: ${mapping.to_table_name}`, error);
logger.error(
`TO 테이블 데이터 삽입 실패: ${mapping.to_table_name}`,
error
);
throw error;
}
@ -513,10 +644,10 @@ export class BatchSchedulerService {
*/
private static mapColumns(record: any, mapping: any) {
const mappedData: any = {};
// 단순한 컬럼 매핑 (실제로는 더 복잡한 로직 필요)
mappedData[mapping.to_column_name] = record[mapping.from_column_name];
return mappedData;
}
@ -531,9 +662,9 @@ export class BatchSchedulerService {
}
this.scheduledTasks.clear();
this.isInitialized = false;
logger.info('모든 배치 스케줄이 중지되었습니다.');
logger.info("모든 배치 스케줄이 중지되었습니다.");
} catch (error) {
logger.error('배치 스케줄 중지 실패:', error);
logger.error("배치 스케줄 중지 실패:", error);
}
}

32
backend-node/src/services/dataMappingService.ts
View File

@ -1,4 +1,4 @@
import { PrismaClient } from "@prisma/client";
import { query } from "../database/db";
import {
DataMappingConfig,
InboundMapping,
@ -11,10 +11,8 @@ import {
} from "../types/dataMappingTypes";
export class DataMappingService {
private prisma: PrismaClient;
constructor() {
this.prisma = new PrismaClient();
// No prisma instance needed
}
/**
@ -404,10 +402,10 @@ export class DataMappingService {
}
// Raw SQL을 사용한 동적 쿼리
const query = `SELECT * FROM ${tableName}${mapping.sourceFilter ? ` WHERE ${mapping.sourceFilter}` : ""}`;
console.log(`🔍 [DataMappingService] 쿼리 실행: ${query}`);
const sql = `SELECT * FROM ${tableName}${mapping.sourceFilter ? ` WHERE ${mapping.sourceFilter}` : ""}`;
console.log(`🔍 [DataMappingService] 쿼리 실행: ${sql}`);
const result = await this.prisma.$queryRawUnsafe(query);
const result = await query<any>(sql, []);
return result;
} catch (error) {
console.error(
@ -429,14 +427,14 @@ export class DataMappingService {
const values = Object.values(data);
const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
const query = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${placeholders})`;
const sql = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${placeholders})`;
console.log(`📝 [DataMappingService] INSERT 실행:`, {
table: tableName,
columns,
query,
query: sql,
});
await this.prisma.$executeRawUnsafe(query, ...values);
await query(sql, values);
}
/**
@ -460,7 +458,7 @@ export class DataMappingService {
.map((col) => `${col} = EXCLUDED.${col}`)
.join(", ");
const query = `
const sql = `
INSERT INTO ${tableName} (${columns.join(", ")})
VALUES (${placeholders})
ON CONFLICT (${keyFields.join(", ")})
@ -470,9 +468,9 @@ export class DataMappingService {
console.log(`🔄 [DataMappingService] UPSERT 실행:`, {
table: tableName,
keyFields,
query,
query: sql,
});
await this.prisma.$executeRawUnsafe(query, ...values);
await query(sql, values);
}
/**
@ -503,14 +501,14 @@ export class DataMappingService {
...keyFields.map((field) => data[field]),
];
const query = `UPDATE ${tableName} SET ${updateClauses} WHERE ${whereConditions}`;
const sql = `UPDATE ${tableName} SET ${updateClauses} WHERE ${whereConditions}`;
console.log(`✏️ [DataMappingService] UPDATE 실행:`, {
table: tableName,
keyFields,
query,
query: sql,
});
await this.prisma.$executeRawUnsafe(query, ...values);
await query(sql, values);
}
/**
@ -570,6 +568,6 @@ export class DataMappingService {
* 리소스 정리
*/
async disconnect(): Promise<void> {
await this.prisma.$disconnect();
// No disconnect needed for raw queries
}
}

57
backend-node/src/services/dataService.ts
View File

@ -1,5 +1,4 @@
import { PrismaClient } from "@prisma/client";
import prisma from "../config/database";
import { query, queryOne } from "../database/db";
interface GetTableDataParams {
tableName: string;
@ -111,7 +110,7 @@ class DataService {
}
// 동적 SQL 쿼리 생성
let query = `SELECT * FROM "${tableName}"`;
let sql = `SELECT * FROM "${tableName}"`;
const queryParams: any[] = [];
let paramIndex = 1;
@ -150,7 +149,7 @@ class DataService {
// WHERE 절 추가
if (whereConditions.length > 0) {
query += ` WHERE ${whereConditions.join(" AND ")}`;
sql += ` WHERE ${whereConditions.join(" AND ")}`;
}
// ORDER BY 절 추가
@ -162,7 +161,7 @@ class DataService {
if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(columnName)) {
const validDirection = direction === "DESC" ? "DESC" : "ASC";
query += ` ORDER BY "${columnName}" ${validDirection}`;
sql += ` ORDER BY "${columnName}" ${validDirection}`;
}
} else {
// 기본 정렬: 최신순 (가능한 컬럼 시도)
@ -179,23 +178,23 @@ class DataService {
);
if (availableDateColumn) {
query += ` ORDER BY "${availableDateColumn}" DESC`;
sql += ` ORDER BY "${availableDateColumn}" DESC`;
}
}
// LIMIT과 OFFSET 추가
query += ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`;
sql += ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`;
queryParams.push(limit, offset);
console.log("🔍 실행할 쿼리:", query);
console.log("🔍 실행할 쿼리:", sql);
console.log("📊 쿼리 파라미터:", queryParams);
// 쿼리 실행
const result = await prisma.$queryRawUnsafe(query, ...queryParams);
const result = await query<any>(sql, queryParams);
return {
success: true,
data: result as any[],
data: result,
};
} catch (error) {
console.error(`데이터 조회 오류 (${tableName}):`, error);
@ -259,18 +258,16 @@ class DataService {
*/
private async checkTableExists(tableName: string): Promise<boolean> {
try {
const result = await prisma.$queryRawUnsafe(
`
SELECT EXISTS (
const result = await query<{ exists: boolean }>(
`SELECT EXISTS (
SELECT FROM information_schema.tables
WHERE table_schema = 'public'
AND table_name = $1
);
`,
tableName
)`,
[tableName]
);
return (result as any)[0]?.exists || false;
return result[0]?.exists || false;
} catch (error) {
console.error("테이블 존재 확인 오류:", error);
return false;
@ -281,18 +278,16 @@ class DataService {
* 테이블 컬럼 정보 조회 (간단 버전)
*/
private async getTableColumnsSimple(tableName: string): Promise<any[]> {
const result = await prisma.$queryRawUnsafe(
`
SELECT column_name, data_type, is_nullable, column_default
const result = await query<any>(
`SELECT column_name, data_type, is_nullable, column_default
FROM information_schema.columns
WHERE table_name = $1
AND table_schema = 'public'
ORDER BY ordinal_position;
`,
tableName
ORDER BY ordinal_position`,
[tableName]
);
return result as any[];
return result;
}
/**
@ -304,19 +299,15 @@ class DataService {
): Promise<string | null> {
try {
// column_labels 테이블에서 라벨 조회
const result = await prisma.$queryRawUnsafe(
`
SELECT label_ko
const result = await query<{ label_ko: string }>(
`SELECT label_ko
FROM column_labels
WHERE table_name = $1 AND column_name = $2
LIMIT 1;
`,
tableName,
columnName
LIMIT 1`,
[tableName, columnName]
);
const labelResult = result as any[];
return labelResult[0]?.label_ko || null;
return result[0]?.label_ko || null;
} catch (error) {
// column_labels 테이블이 없거나 오류가 발생하면 null 반환
return null;

283
backend-node/src/services/dbTypeCategoryService.ts
View File

@ -1,6 +1,4 @@
import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient();
import { query, queryOne } from "../database/db";
export interface DbTypeCategory {
type_code: string;
@ -42,25 +40,24 @@ export class DbTypeCategoryService {
*/
static async getAllCategories(): Promise<ApiResponse<DbTypeCategory[]>> {
try {
const categories = await prisma.db_type_categories.findMany({
where: { is_active: true },
orderBy: [
{ sort_order: 'asc' },
{ display_name: 'asc' }
]
});
const categories = await query<DbTypeCategory>(
`SELECT * FROM db_type_categories
WHERE is_active = $1
ORDER BY sort_order ASC, display_name ASC`,
[true]
);
return {
success: true,
data: categories,
message: "DB 타입 카테고리 목록을 조회했습니다."
message: "DB 타입 카테고리 목록을 조회했습니다.",
};
} catch (error) {
console.error("DB 타입 카테고리 조회 오류:", error);
return {
success: false,
message: "DB 타입 카테고리 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -68,30 +65,33 @@ export class DbTypeCategoryService {
/**
* 특정 DB 타입 카테고리 조회
*/
static async getCategoryByTypeCode(typeCode: string): Promise<ApiResponse<DbTypeCategory>> {
static async getCategoryByTypeCode(
typeCode: string
): Promise<ApiResponse<DbTypeCategory>> {
try {
const category = await prisma.db_type_categories.findUnique({
where: { type_code: typeCode }
});
const category = await queryOne<DbTypeCategory>(
`SELECT * FROM db_type_categories WHERE type_code = $1`,
[typeCode]
);
if (!category) {
return {
success: false,
message: "해당 DB 타입 카테고리를 찾을 수 없습니다."
message: "해당 DB 타입 카테고리를 찾을 수 없습니다.",
};
}
return {
success: true,
data: category,
message: "DB 타입 카테고리를 조회했습니다."
message: "DB 타입 카테고리를 조회했습니다.",
};
} catch (error) {
console.error("DB 타입 카테고리 조회 오류:", error);
return {
success: false,
message: "DB 타입 카테고리 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -99,41 +99,49 @@ export class DbTypeCategoryService {
/**
* DB 타입 카테고리 생성
*/
static async createCategory(data: CreateDbTypeCategoryRequest): Promise<ApiResponse<DbTypeCategory>> {
static async createCategory(
data: CreateDbTypeCategoryRequest
): Promise<ApiResponse<DbTypeCategory>> {
try {
// 중복 체크
const existing = await prisma.db_type_categories.findUnique({
where: { type_code: data.type_code }
});
const existing = await queryOne<DbTypeCategory>(
`SELECT * FROM db_type_categories WHERE type_code = $1`,
[data.type_code]
);
if (existing) {
return {
success: false,
message: "이미 존재하는 DB 타입 코드입니다."
message: "이미 존재하는 DB 타입 코드입니다.",
};
}
const category = await prisma.db_type_categories.create({
data: {
type_code: data.type_code,
display_name: data.display_name,
icon: data.icon,
color: data.color,
sort_order: data.sort_order || 0
}
});
const category = await queryOne<DbTypeCategory>(
`INSERT INTO db_type_categories
(type_code, display_name, icon, color, sort_order, is_active, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW())
RETURNING *`,
[
data.type_code,
data.display_name,
data.icon || null,
data.color || null,
data.sort_order || 0,
true,
]
);
return {
success: true,
data: category,
message: "DB 타입 카테고리가 생성되었습니다."
data: category || undefined,
message: "DB 타입 카테고리가 생성되었습니다.",
};
} catch (error) {
console.error("DB 타입 카테고리 생성 오류:", error);
return {
success: false,
message: "DB 타입 카테고리 생성 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -141,31 +149,56 @@ export class DbTypeCategoryService {
/**
* DB 타입 카테고리 수정
*/
static async updateCategory(typeCode: string, data: UpdateDbTypeCategoryRequest): Promise<ApiResponse<DbTypeCategory>> {
static async updateCategory(
typeCode: string,
data: UpdateDbTypeCategoryRequest
): Promise<ApiResponse<DbTypeCategory>> {
try {
const category = await prisma.db_type_categories.update({
where: { type_code: typeCode },
data: {
display_name: data.display_name,
icon: data.icon,
color: data.color,
sort_order: data.sort_order,
is_active: data.is_active,
updated_at: new Date()
}
});
// 동적 UPDATE 쿼리 생성
const updateFields: string[] = ["updated_at = NOW()"];
const values: any[] = [];
let paramIndex = 1;
if (data.display_name !== undefined) {
updateFields.push(`display_name = $${paramIndex++}`);
values.push(data.display_name);
}
if (data.icon !== undefined) {
updateFields.push(`icon = $${paramIndex++}`);
values.push(data.icon);
}
if (data.color !== undefined) {
updateFields.push(`color = $${paramIndex++}`);
values.push(data.color);
}
if (data.sort_order !== undefined) {
updateFields.push(`sort_order = $${paramIndex++}`);
values.push(data.sort_order);
}
if (data.is_active !== undefined) {
updateFields.push(`is_active = $${paramIndex++}`);
values.push(data.is_active);
}
const category = await queryOne<DbTypeCategory>(
`UPDATE db_type_categories
SET ${updateFields.join(", ")}
WHERE type_code = $${paramIndex}
RETURNING *`,
[...values, typeCode]
);
return {
success: true,
data: category,
message: "DB 타입 카테고리가 수정되었습니다."
data: category || undefined,
message: "DB 타입 카테고리가 수정되었습니다.",
};
} catch (error) {
console.error("DB 타입 카테고리 수정 오류:", error);
return {
success: false,
message: "DB 타입 카테고리 수정 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -176,38 +209,37 @@ export class DbTypeCategoryService {
static async deleteCategory(typeCode: string): Promise<ApiResponse<void>> {
try {
// 해당 타입을 사용하는 연결이 있는지 확인
const connectionsCount = await prisma.external_db_connections.count({
where: {
db_type: typeCode,
is_active: "Y"
}
});
const countResult = await queryOne<{ count: string }>(
`SELECT COUNT(*) as count FROM external_db_connections
WHERE db_type = $1 AND is_active = $2`,
[typeCode, "Y"]
);
const connectionsCount = parseInt(countResult?.count || "0");
if (connectionsCount > 0) {
return {
success: false,
message: `해당 DB 타입을 사용하는 연결이 ${connectionsCount}개 있어 삭제할 수 없습니다.`
message: `해당 DB 타입을 사용하는 연결이 ${connectionsCount}개 있어 삭제할 수 없습니다.`,
};
}
await prisma.db_type_categories.update({
where: { type_code: typeCode },
data: {
is_active: false,
updated_at: new Date()
}
});
await query(
`UPDATE db_type_categories
SET is_active = $1, updated_at = NOW()
WHERE type_code = $2`,
[false, typeCode]
);
return {
success: true,
message: "DB 타입 카테고리가 삭제되었습니다."
message: "DB 타입 카테고리가 삭제되었습니다.",
};
} catch (error) {
console.error("DB 타입 카테고리 삭제 오류:", error);
return {
success: false,
message: "DB 타입 카테고리 삭제 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -217,38 +249,36 @@ export class DbTypeCategoryService {
*/
static async getConnectionStatsByType(): Promise<ApiResponse<any[]>> {
try {
const stats = await prisma.external_db_connections.groupBy({
by: ['db_type'],
where: { is_active: "Y" },
_count: {
id: true
}
});
// LEFT JOIN으로 한 번에 조회
const result = await query<any>(
`SELECT
c.*,
COUNT(e.id) as connection_count
FROM db_type_categories c
LEFT JOIN external_db_connections e ON c.type_code = e.db_type AND e.is_active = $1
WHERE c.is_active = $2
GROUP BY c.type_code, c.display_name, c.icon, c.color, c.sort_order, c.is_active, c.created_at, c.updated_at
ORDER BY c.sort_order ASC`,
["Y", true]
);
// 카테고리 정보와 함께 반환
const categories = await prisma.db_type_categories.findMany({
where: { is_active: true }
});
const result = categories.map(category => {
const stat = stats.find(s => s.db_type === category.type_code);
return {
...category,
connection_count: stat?._count.id || 0
};
});
// connection_count를 숫자로 변환
const formattedResult = result.map((row) => ({
...row,
connection_count: parseInt(row.connection_count),
}));
return {
success: true,
data: result,
message: "DB 타입별 연결 통계를 조회했습니다."
data: formattedResult,
message: "DB 타입별 연결 통계를 조회했습니다.",
};
} catch (error) {
console.error("DB 타입별 통계 조회 오류:", error);
return {
success: false,
message: "DB 타입별 통계 조회 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}
@ -260,60 +290,69 @@ export class DbTypeCategoryService {
try {
const defaultCategories = [
{
type_code: 'postgresql',
display_name: 'PostgreSQL',
icon: 'postgresql',
color: '#336791',
sort_order: 1
type_code: "postgresql",
display_name: "PostgreSQL",
icon: "postgresql",
color: "#336791",
sort_order: 1,
},
{
type_code: 'oracle',
display_name: 'Oracle',
icon: 'oracle',
color: '#F80000',
sort_order: 2
type_code: "oracle",
display_name: "Oracle",
icon: "oracle",
color: "#F80000",
sort_order: 2,
},
{
type_code: 'mysql',
display_name: 'MySQL',
icon: 'mysql',
color: '#4479A1',
sort_order: 3
type_code: "mysql",
display_name: "MySQL",
icon: "mysql",
color: "#4479A1",
sort_order: 3,
},
{
type_code: 'mariadb',
display_name: 'MariaDB',
icon: 'mariadb',
color: '#003545',
sort_order: 4
type_code: "mariadb",
display_name: "MariaDB",
icon: "mariadb",
color: "#003545",
sort_order: 4,
},
{
type_code: 'mssql',
display_name: 'SQL Server',
icon: 'mssql',
color: '#CC2927',
sort_order: 5
}
type_code: "mssql",
display_name: "SQL Server",
icon: "mssql",
color: "#CC2927",
sort_order: 5,
},
];
for (const category of defaultCategories) {
await prisma.db_type_categories.upsert({
where: { type_code: category.type_code },
update: {},
create: category
});
await query(
`INSERT INTO db_type_categories
(type_code, display_name, icon, color, sort_order, is_active, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW())
ON CONFLICT (type_code) DO NOTHING`,
[
category.type_code,
category.display_name,
category.icon,
category.color,
category.sort_order,
true,
]
);
}
return {
success: true,
message: "기본 DB 타입 카테고리가 초기화되었습니다."
message: "기본 DB 타입 카테고리가 초기화되었습니다.",
};
} catch (error) {
console.error("기본 카테고리 초기화 오류:", error);
return {
success: false,
message: "기본 카테고리 초기화 중 오류가 발생했습니다.",
error: error instanceof Error ? error.message : "알 수 없는 오류"
error: error instanceof Error ? error.message : "알 수 없는 오류",
};
}
}

111
backend-node/src/services/ddlAuditLogger.ts
View File

@ -3,11 +3,9 @@
* 모든 DDL 실행을 추적하고 기록
*/
import { PrismaClient } from "@prisma/client";
import { query, queryOne } from "../database/db";
import { logger } from "../utils/logger";
const prisma = new PrismaClient();
export class DDLAuditLogger {
/**
* DDL 실행 로그 기록
@ -24,8 +22,8 @@ export class DDLAuditLogger {
): Promise<void> {
try {
// DDL 실행 로그 데이터베이스에 저장
const logEntry = await prisma.$executeRaw`
INSERT INTO ddl_execution_log (
await query(
`INSERT INTO ddl_execution_log (
user_id,
company_code,
ddl_type,
@ -34,17 +32,17 @@ export class DDLAuditLogger {
success,
error_message,
executed_at
) VALUES (
${userId},
${companyCode},
${ddlType},
${tableName},
${ddlQuery},
${success},
${error || null},
NOW()
)
`;
) VALUES ($1, $2, $3, $4, $5, $6, $7, NOW())`,
[
userId,
companyCode,
ddlType,
tableName,
ddlQuery,
success,
error || null,
]
);
// 추가 로깅 (파일 로그)
const logData = {
@ -137,7 +135,7 @@ export class DDLAuditLogger {
params.push(ddlType);
}
const query = `
const sql = `
SELECT
id,
user_id,
@ -159,8 +157,8 @@ export class DDLAuditLogger {
params.push(limit);
const logs = await prisma.$queryRawUnsafe(query, ...params);
return logs as any[];
const logs = await query<any>(sql, params);
return logs;
} catch (error) {
logger.error("DDL 로그 조회 실패:", error);
return [];
@ -196,47 +194,40 @@ export class DDLAuditLogger {
}
// 전체 통계
const totalStats = (await prisma.$queryRawUnsafe(
`
SELECT
const totalStats = await query<any>(
`SELECT
COUNT(*) as total_executions,
SUM(CASE WHEN success = true THEN 1 ELSE 0 END) as successful_executions,
SUM(CASE WHEN success = false THEN 1 ELSE 0 END) as failed_executions
FROM ddl_execution_log
WHERE 1=1 ${dateFilter}
`,
...params
)) as any[];
WHERE 1=1 ${dateFilter}`,
params
);
// DDL 타입별 통계
const ddlTypeStats = (await prisma.$queryRawUnsafe(
`
SELECT ddl_type, COUNT(*) as count
const ddlTypeStats = await query<any>(
`SELECT ddl_type, COUNT(*) as count
FROM ddl_execution_log
WHERE 1=1 ${dateFilter}
GROUP BY ddl_type
ORDER BY count DESC
`,
...params
)) as any[];
ORDER BY count DESC`,
params
);
// 사용자별 통계
const userStats = (await prisma.$queryRawUnsafe(
`
SELECT user_id, COUNT(*) as count
const userStats = await query<any>(
`SELECT user_id, COUNT(*) as count
FROM ddl_execution_log
WHERE 1=1 ${dateFilter}
GROUP BY user_id
ORDER BY count DESC
LIMIT 10
`,
...params
)) as any[];
LIMIT 10`,
params
);
// 최근 실패 로그
const recentFailures = (await prisma.$queryRawUnsafe(
`
SELECT
const recentFailures = await query<any>(
`SELECT
user_id,
ddl_type,
table_name,
@ -245,10 +236,9 @@ export class DDLAuditLogger {
FROM ddl_execution_log
WHERE success = false ${dateFilter}
ORDER BY executed_at DESC
LIMIT 10
`,
...params
)) as any[];
LIMIT 10`,
params
);
const stats = totalStats[0];
@ -284,9 +274,8 @@ export class DDLAuditLogger {
*/
static async getTableDDLHistory(tableName: string): Promise<any[]> {
try {
const history = await prisma.$queryRawUnsafe(
`
SELECT
const history = await query<any>(
`SELECT
id,
user_id,
ddl_type,
@ -297,12 +286,11 @@ export class DDLAuditLogger {
FROM ddl_execution_log
WHERE table_name = $1
ORDER BY executed_at DESC
LIMIT 20
`,
tableName
LIMIT 20`,
[tableName]
);
return history as any[];
return history;
} catch (error) {
logger.error(`테이블 '${tableName}' DDL 히스토리 조회 실패:`, error);
return [];
@ -317,17 +305,20 @@ export class DDLAuditLogger {
const cutoffDate = new Date();
cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
const result = await prisma.$executeRaw`
DELETE FROM ddl_execution_log
WHERE executed_at < ${cutoffDate}
`;
const result = await query(
`DELETE FROM ddl_execution_log
WHERE executed_at < $1`,
[cutoffDate]
);
logger.info(`DDL 로그 정리 완료: ${result}개 레코드 삭제`, {
const deletedCount = result.length;
logger.info(`DDL 로그 정리 완료: ${deletedCount}개 레코드 삭제`, {
retentionDays,
cutoffDate: cutoffDate.toISOString(),
});
return result as number;
return deletedCount;
} catch (error) {
logger.error("DDL 로그 정리 실패:", error);
return 0;

67
backend-node/src/services/enhancedDynamicFormService.ts
View File

@ -3,7 +3,7 @@
* 타입 안전성과 검증 강화
*/
import { PrismaClient } from "@prisma/client";
import { query, queryOne } from "../database/db";
import {
WebType,
DynamicWebType,
@ -14,8 +14,6 @@ import {
} from "../types/unified-web-types";
import { DataflowControlService } from "./dataflowControlService";
const prisma = new PrismaClient();
// 테이블 컬럼 정보
export interface TableColumn {
column_name: string;
@ -156,17 +154,15 @@ export class EnhancedDynamicFormService {
*/
private async validateTableExists(tableName: string): Promise<boolean> {
try {
const result = await prisma.$queryRawUnsafe(
`
SELECT EXISTS (
const result = await query<{ exists: boolean }>(
`SELECT EXISTS (
SELECT FROM information_schema.tables
WHERE table_name = $1
) as exists
`,
tableName
) as exists`,
[tableName]
);
return (result as any)[0]?.exists || false;
return result[0]?.exists || false;
} catch (error) {
console.error(`❌ 테이블 존재 여부 확인 실패: ${tableName}`, error);
return false;
@ -184,9 +180,8 @@ export class EnhancedDynamicFormService {
}
try {
const columns = (await prisma.$queryRawUnsafe(
`
SELECT
const columns = await query<TableColumn>(
`SELECT
column_name,
data_type,
is_nullable,
@ -196,10 +191,9 @@ export class EnhancedDynamicFormService {
numeric_scale
FROM information_schema.columns
WHERE table_name = $1
ORDER BY ordinal_position
`,
tableName
)) as TableColumn[];
ORDER BY ordinal_position`,
[tableName]
);
// 캐시 저장 (10분)
this.columnCache.set(tableName, columns);
@ -226,18 +220,21 @@ export class EnhancedDynamicFormService {
try {
// table_type_columns에서 웹타입 정보 조회
const webTypeData = (await prisma.$queryRawUnsafe(
`
SELECT
const webTypeData = await query<{
column_name: string;
web_type: string;
is_nullable: string;
detail_settings: any;
}>(
`SELECT
column_name,
web_type,
is_nullable,
detail_settings
FROM table_type_columns
WHERE table_name = $1
`,
tableName
)) as any[];
WHERE table_name = $1`,
[tableName]
);
const columnWebTypes: ColumnWebTypeInfo[] = webTypeData.map((row) => ({
columnName: row.column_name,
@ -555,15 +552,13 @@ export class EnhancedDynamicFormService {
*/
private async getPrimaryKeys(tableName: string): Promise<string[]> {
try {
const result = (await prisma.$queryRawUnsafe(
`
SELECT column_name
const result = await query<{ column_name: string }>(
`SELECT column_name
FROM information_schema.key_column_usage
WHERE table_name = $1
AND constraint_name LIKE '%_pkey'
`,
tableName
)) as any[];
AND constraint_name LIKE '%_pkey'`,
[tableName]
);
return result.map((row) => row.column_name);
} catch (error) {
@ -594,10 +589,7 @@ export class EnhancedDynamicFormService {
query: insertQuery.replace(/\n\s+/g, " "),
});
const result = (await prisma.$queryRawUnsafe(
insertQuery,
...values
)) as any[];
const result = await query<any>(insertQuery, values);
return {
data: result[0],
@ -649,10 +641,7 @@ export class EnhancedDynamicFormService {
query: updateQuery.replace(/\n\s+/g, " "),
});
const result = (await prisma.$queryRawUnsafe(
updateQuery,
...updateValues
)) as any[];
const result = await query<any>(updateQuery, updateValues);
return {
data: result[0],

92
backend-node/src/services/entityJoinService.ts
View File

@ -1,5 +1,4 @@
import { PrismaClient } from "@prisma/client";
import prisma from "../config/database";
import { query, queryOne } from "../database/db";
import { logger } from "../utils/logger";
import {
EntityJoinConfig,
@ -26,20 +25,20 @@ export class EntityJoinService {
logger.info(`Entity 컬럼 감지 시작: ${tableName}`);
// column_labels에서 entity 타입인 컬럼들 조회
const entityColumns = await prisma.column_labels.findMany({
where: {
table_name: tableName,
web_type: "entity",
reference_table: { not: null },
reference_column: { not: null },
},
select: {
column_name: true,
reference_table: true,
reference_column: true,
display_column: true,
},
});
const entityColumns = await query<{
column_name: string;
reference_table: string;
reference_column: string;
display_column: string | null;
}>(
`SELECT column_name, reference_table, reference_column, display_column
FROM column_labels
WHERE table_name = $1
AND web_type = $2
AND reference_table IS NOT NULL
AND reference_column IS NOT NULL`,
[tableName, "entity"]
);
logger.info(`🔍 Entity 컬럼 조회 결과: ${entityColumns.length}개 발견`);
entityColumns.forEach((col, index) => {
@ -401,13 +400,14 @@ export class EntityJoinService {
});
// 참조 테이블 존재 확인
const tableExists = await prisma.$queryRaw`
SELECT 1 FROM information_schema.tables
WHERE table_name = ${config.referenceTable}
LIMIT 1
`;
const tableExists = await query<{ exists: number }>(
`SELECT 1 as exists FROM information_schema.tables
WHERE table_name = $1
LIMIT 1`,
[config.referenceTable]
);
if (!Array.isArray(tableExists) || tableExists.length === 0) {
if (tableExists.length === 0) {
logger.warn(`참조 테이블이 존재하지 않음: ${config.referenceTable}`);
return false;
}
@ -420,14 +420,15 @@ export class EntityJoinService {
// 🚨 display_column이 항상 "none"이므로, 표시 컬럼이 없어도 조인 허용
if (displayColumn && displayColumn !== "none") {
const columnExists = await prisma.$queryRaw`
SELECT 1 FROM information_schema.columns
WHERE table_name = ${config.referenceTable}
AND column_name = ${displayColumn}
LIMIT 1
`;
const columnExists = await query<{ exists: number }>(
`SELECT 1 as exists FROM information_schema.columns
WHERE table_name = $1
AND column_name = $2
LIMIT 1`,
[config.referenceTable, displayColumn]
);
if (!Array.isArray(columnExists) || columnExists.length === 0) {
if (columnExists.length === 0) {
logger.warn(
`표시 컬럼이 존재하지 않음: ${config.referenceTable}.${displayColumn}`
);
@ -528,27 +529,30 @@ export class EntityJoinService {
> {
try {
// 1. 테이블의 기본 컬럼 정보 조회
const columns = (await prisma.$queryRaw`
SELECT
const columns = await query<{
column_name: string;
data_type: string;
}>(
`SELECT
column_name,
data_type
FROM information_schema.columns
WHERE table_name = ${tableName}
WHERE table_name = $1
AND data_type IN ('character varying', 'varchar', 'text', 'char')
ORDER BY ordinal_position
`) as Array<{
column_name: string;
data_type: string;
}>;
ORDER BY ordinal_position`,
[tableName]
);
// 2. column_labels 테이블에서 라벨 정보 조회
const columnLabels = await prisma.column_labels.findMany({
where: { table_name: tableName },
select: {
column_name: true,
column_label: true,
},
});
const columnLabels = await query<{
column_name: string;
column_label: string | null;
}>(
`SELECT column_name, column_label
FROM column_labels
WHERE table_name = $1`,
[tableName]
);
// 3. 라벨 정보를 맵으로 변환
const labelMap = new Map<string, string>();

55
backend-node/src/services/eventTriggerService.ts
View File

@ -1,8 +1,6 @@
import { PrismaClient } from "@prisma/client";
import { query, queryOne } from "../database/db";
import { logger } from "../utils/logger";
const prisma = new PrismaClient();
// 조건 노드 타입 정의
interface ConditionNode {
id: string; // 고유 ID
@ -92,15 +90,16 @@ export class EventTriggerService {
try {
// 🔥 수정: Raw SQL을 사용하여 JSON 배열 검색
const diagrams = (await prisma.$queryRaw`
SELECT * FROM dataflow_diagrams
WHERE company_code = ${companyCode}
AND (
category::text = '"data-save"' OR
category::jsonb ? 'data-save' OR
category::jsonb @> '["data-save"]'
)
`) as any[];
const diagrams = await query<any>(
`SELECT * FROM dataflow_diagrams
WHERE company_code = $1
AND (
category::text = '"data-save"' OR
category::jsonb ? 'data-save' OR
category::jsonb @> '["data-save"]'
)`,
[companyCode]
);
// 각 관계도에서 해당 테이블을 소스로 하는 데이터 저장 관계들 필터링
const matchingDiagrams = diagrams.filter((diagram) => {
@ -537,13 +536,14 @@ export class EventTriggerService {
data: Record<string, any>
): Promise<void> {
// 동적 테이블 INSERT 실행
const sql = `INSERT INTO ${tableName} (${Object.keys(data).join(", ")}) VALUES (${Object.keys(
data
)
.map(() => "?")
.join(", ")})`;
// PostgreSQL 파라미터 플레이스홀더로 변경 (? → $1, $2, ...)
const values = Object.values(data);
const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
const sql = `INSERT INTO ${tableName} (${Object.keys(data).join(
", "
)}) VALUES (${placeholders})`;
await prisma.$executeRawUnsafe(sql, ...Object.values(data));
await query(sql, values);
logger.info(`Inserted data into ${tableName}:`, data);
}
@ -563,14 +563,15 @@ export class EventTriggerService {
}
// 동적 테이블 UPDATE 실행
const values = Object.values(data);
const setClause = Object.keys(data)
.map((key) => `${key} = ?`)
.map((key, i) => `${key} = $${i + 1}`)
.join(", ");
const whereClause = this.buildWhereClause(conditions);
const sql = `UPDATE ${tableName} SET ${setClause} WHERE ${whereClause}`;
await prisma.$executeRawUnsafe(sql, ...Object.values(data));
await query(sql, values);
logger.info(`Updated data in ${tableName}:`, data);
}
@ -593,7 +594,7 @@ export class EventTriggerService {
const whereClause = this.buildWhereClause(conditions);
const sql = `DELETE FROM ${tableName} WHERE ${whereClause}`;
await prisma.$executeRawUnsafe(sql);
await query(sql, []);
logger.info(`Deleted data from ${tableName} with conditions`);
}
@ -608,15 +609,16 @@ export class EventTriggerService {
const columns = Object.keys(data);
const values = Object.values(data);
const conflictColumns = ["id", "company_code"]; // 기본 충돌 컬럼
const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
const sql = `
INSERT INTO ${tableName} (${columns.join(", ")})
VALUES (${columns.map(() => "?").join(", ")})
VALUES (${placeholders})
ON CONFLICT (${conflictColumns.join(", ")})
DO UPDATE SET ${columns.map((col) => `${col} = EXCLUDED.${col}`).join(", ")}
`;
await prisma.$executeRawUnsafe(sql, ...values);
await query(sql, values);
logger.info(`Upserted data into ${tableName}:`, data);
}
@ -678,9 +680,10 @@ export class EventTriggerService {
companyCode: string
): Promise<{ conditionMet: boolean; result?: ExecutionResult }> {
try {
const diagram = await prisma.dataflow_diagrams.findUnique({
where: { diagram_id: diagramId },
});
const diagram = await queryOne<any>(
`SELECT * FROM dataflow_diagrams WHERE diagram_id = $1`,
[diagramId]
);
if (!diagram) {
throw new Error(`Diagram ${diagramId} not found`);

224
backend-node/src/services/externalCallConfigService.ts
View File

@ -1,4 +1,4 @@
import prisma from "../config/database";
import { query, queryOne } from "../database/db";
import { logger } from "../utils/logger";
// 외부 호출 설정 타입 정의
@ -34,43 +34,55 @@ export class ExternalCallConfigService {
logger.info("=== 외부 호출 설정 목록 조회 시작 ===");
logger.info(`필터 조건:`, filter);
const where: any = {};
const conditions: string[] = [];
const params: any[] = [];
let paramIndex = 1;
// 회사 코드 필터
if (filter.company_code) {
where.company_code = filter.company_code;
conditions.push(`company_code = $${paramIndex++}`);
params.push(filter.company_code);
}
// 호출 타입 필터
if (filter.call_type) {
where.call_type = filter.call_type;
conditions.push(`call_type = $${paramIndex++}`);
params.push(filter.call_type);
}
// API 타입 필터
if (filter.api_type) {
where.api_type = filter.api_type;
conditions.push(`api_type = $${paramIndex++}`);
params.push(filter.api_type);
}
// 활성화 상태 필터
if (filter.is_active) {
where.is_active = filter.is_active;
conditions.push(`is_active = $${paramIndex++}`);
params.push(filter.is_active);
}
// 검색어 필터 (설정 이름 또는 설명)
if (filter.search) {
where.OR = [
{ config_name: { contains: filter.search, mode: "insensitive" } },
{ description: { contains: filter.search, mode: "insensitive" } },
];
conditions.push(
`(config_name ILIKE $${paramIndex} OR description ILIKE $${paramIndex})`
);
params.push(`%${filter.search}%`);
paramIndex++;
}
const configs = await prisma.external_call_configs.findMany({
where,
orderBy: [{ is_active: "desc" }, { created_date: "desc" }],
});
const whereClause =
conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
const configs = await query<ExternalCallConfig>(
`SELECT * FROM external_call_configs
${whereClause}
ORDER BY is_active DESC, created_date DESC`,
params
);
logger.info(`외부 호출 설정 조회 결과: ${configs.length}개`);
return configs as ExternalCallConfig[];
return configs;
} catch (error) {
logger.error("외부 호출 설정 목록 조회 실패:", error);
throw error;
@ -84,9 +96,10 @@ export class ExternalCallConfigService {
try {
logger.info(`=== 외부 호출 설정 조회: ID ${id} ===`);
const config = await prisma.external_call_configs.findUnique({
where: { id },
});
const config = await queryOne<ExternalCallConfig>(
`SELECT * FROM external_call_configs WHERE id = $1`,
[id]
);
if (config) {
logger.info(`외부 호출 설정 조회 성공: ${config.config_name}`);
@ -94,7 +107,7 @@ export class ExternalCallConfigService {
logger.warn(`외부 호출 설정을 찾을 수 없음: ID ${id}`);
}
return config as ExternalCallConfig | null;
return config || null;
} catch (error) {
logger.error(`외부 호출 설정 조회 실패 (ID: ${id}):`, error);
throw error;
@ -115,13 +128,11 @@ export class ExternalCallConfigService {
});
// 중복 이름 검사
const existingConfig = await prisma.external_call_configs.findFirst({
where: {
config_name: data.config_name,
company_code: data.company_code || "*",
is_active: "Y",
},
});
const existingConfig = await queryOne<ExternalCallConfig>(
`SELECT * FROM external_call_configs
WHERE config_name = $1 AND company_code = $2 AND is_active = $3`,
[data.config_name, data.company_code || "*", "Y"]
);
if (existingConfig) {
throw new Error(
@ -129,24 +140,29 @@ export class ExternalCallConfigService {
);
}
const newConfig = await prisma.external_call_configs.create({
data: {
config_name: data.config_name,
call_type: data.call_type,
api_type: data.api_type,
config_data: data.config_data,
description: data.description,
company_code: data.company_code || "*",
is_active: data.is_active || "Y",
created_by: data.created_by,
updated_by: data.updated_by,
},
});
const newConfig = await queryOne<ExternalCallConfig>(
`INSERT INTO external_call_configs
(config_name, call_type, api_type, config_data, description,
company_code, is_active, created_by, updated_by, created_date, updated_date)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW(), NOW())
RETURNING *`,
[
data.config_name,
data.call_type,
data.api_type,
JSON.stringify(data.config_data),
data.description,
data.company_code || "*",
data.is_active || "Y",
data.created_by,
data.updated_by,
]
);
logger.info(
`외부 호출 설정 생성 완료: ${newConfig.config_name} (ID: ${newConfig.id})`
`외부 호출 설정 생성 완료: ${newConfig!.config_name} (ID: ${newConfig!.id})`
);
return newConfig as ExternalCallConfig;
return newConfig!;
} catch (error) {
logger.error("외부 호출 설정 생성 실패:", error);
throw error;
@ -171,14 +187,16 @@ export class ExternalCallConfigService {
// 이름 중복 검사 (다른 설정과 중복되는지)
if (data.config_name && data.config_name !== existingConfig.config_name) {
const duplicateConfig = await prisma.external_call_configs.findFirst({
where: {
config_name: data.config_name,
company_code: data.company_code || existingConfig.company_code,
is_active: "Y",
id: { not: id },
},
});
const duplicateConfig = await queryOne<ExternalCallConfig>(
`SELECT * FROM external_call_configs
WHERE config_name = $1 AND company_code = $2 AND is_active = $3 AND id != $4`,
[
data.config_name,
data.company_code || existingConfig.company_code,
"Y",
id,
]
);
if (duplicateConfig) {
throw new Error(
@ -187,27 +205,58 @@ export class ExternalCallConfigService {
}
}
const updatedConfig = await prisma.external_call_configs.update({
where: { id },
data: {
...(data.config_name && { config_name: data.config_name }),
...(data.call_type && { call_type: data.call_type }),
...(data.api_type !== undefined && { api_type: data.api_type }),
...(data.config_data && { config_data: data.config_data }),
...(data.description !== undefined && {
description: data.description,
}),
...(data.company_code && { company_code: data.company_code }),
...(data.is_active && { is_active: data.is_active }),
...(data.updated_by && { updated_by: data.updated_by }),
updated_date: new Date(),
},
});
// 동적 UPDATE 쿼리 생성
const updateFields: string[] = ["updated_date = NOW()"];
const params: any[] = [];
let paramIndex = 1;
if (data.config_name) {
updateFields.push(`config_name = $${paramIndex++}`);
params.push(data.config_name);
}
if (data.call_type) {
updateFields.push(`call_type = $${paramIndex++}`);
params.push(data.call_type);
}
if (data.api_type !== undefined) {
updateFields.push(`api_type = $${paramIndex++}`);
params.push(data.api_type);
}
if (data.config_data) {
updateFields.push(`config_data = $${paramIndex++}`);
params.push(JSON.stringify(data.config_data));
}
if (data.description !== undefined) {
updateFields.push(`description = $${paramIndex++}`);
params.push(data.description);
}
if (data.company_code) {
updateFields.push(`company_code = $${paramIndex++}`);
params.push(data.company_code);
}
if (data.is_active) {
updateFields.push(`is_active = $${paramIndex++}`);
params.push(data.is_active);
}
if (data.updated_by) {
updateFields.push(`updated_by = $${paramIndex++}`);
params.push(data.updated_by);
}
params.push(id);
const updatedConfig = await queryOne<ExternalCallConfig>(
`UPDATE external_call_configs
SET ${updateFields.join(", ")}
WHERE id = $${paramIndex}
RETURNING *`,
params
);
logger.info(
`외부 호출 설정 수정 완료: ${updatedConfig.config_name} (ID: ${id})`
`외부 호출 설정 수정 완료: ${updatedConfig!.config_name} (ID: ${id})`
);
return updatedConfig as ExternalCallConfig;
return updatedConfig!;
} catch (error) {
logger.error(`외부 호출 설정 수정 실패 (ID: ${id}):`, error);
throw error;
@ -228,14 +277,12 @@ export class ExternalCallConfigService {
}
// 논리 삭제 (is_active = 'N')
await prisma.external_call_configs.update({
where: { id },
data: {
is_active: "N",
updated_by: deletedBy,
updated_date: new Date(),
},
});
await query(
`UPDATE external_call_configs
SET is_active = $1, updated_by = $2, updated_date = NOW()
WHERE id = $3`,
["N", deletedBy, id]
);
logger.info(
`외부 호출 설정 삭제 완료: ${existingConfig.config_name} (ID: ${id})`
@ -401,21 +448,18 @@ export class ExternalCallConfigService {
}>
> {
try {
const configs = await prisma.external_call_configs.findMany({
where: {
company_code: companyCode,
is_active: "Y",
},
select: {
id: true,
config_name: true,
description: true,
config_data: true,
},
orderBy: {
config_name: "asc",
},
});
const configs = await query<{
id: number;
config_name: string;
description: string | null;
config_data: any;
}>(
`SELECT id, config_name, description, config_data
FROM external_call_configs
WHERE company_code = $1 AND is_active = $2
ORDER BY config_name ASC`,
[companyCode, "Y"]
);
return configs.map((config) => {
const configData = config.config_data as any;

24
backend-node/src/services/multiConnectionQueryService.ts
View File

@ -8,7 +8,7 @@ import { ExternalDbConnectionService } from "./externalDbConnectionService";
import { TableManagementService } from "./tableManagementService";
import { ExternalDbConnection, ApiResponse } from "../types/externalDbTypes";
import { ColumnTypeInfo, TableInfo } from "../types/tableManagement";
import prisma from "../config/database";
import { query } from "../database/db";
import { logger } from "../utils/logger";
// 🔧 Prisma 클라이언트 중복 생성 방지 - 기존 인스턴스 재사용
@ -991,18 +991,18 @@ export class MultiConnectionQueryService {
switch (operation) {
case "select":
let query = `SELECT * FROM ${tableName}`;
let sql = `SELECT * FROM ${tableName}`;
const queryParams: any[] = [];
if (conditions && Object.keys(conditions).length > 0) {
const whereClause = Object.keys(conditions)
.map((key, index) => `${key} = $${index + 1}`)
.join(" AND ");
query += ` WHERE ${whereClause}`;
sql += ` WHERE ${whereClause}`;
queryParams.push(...Object.values(conditions));
}
return await prisma.$queryRawUnsafe(query, ...queryParams);
return await query(sql, queryParams);
case "insert":
if (!data) throw new Error("INSERT 작업에는 데이터가 필요합니다.");
@ -1019,11 +1019,10 @@ export class MultiConnectionQueryService {
RETURNING *
`;
const insertResult = await prisma.$queryRawUnsafe(
insertQuery,
...insertValues
);
return Array.isArray(insertResult) ? insertResult[0] : insertResult;
const insertResult = await query(insertQuery, insertValues);
return Array.isArray(insertResult) && insertResult.length > 0
? insertResult[0]
: insertResult;
case "update":
if (!data) throw new Error("UPDATE 작업에는 데이터가 필요합니다.");
@ -1052,7 +1051,7 @@ export class MultiConnectionQueryService {
...Object.values(data),
...Object.values(conditions),
];
return await prisma.$queryRawUnsafe(updateQuery, ...updateParams);
return await query(updateQuery, updateParams);
case "delete":
if (!conditions)
@ -1068,10 +1067,7 @@ export class MultiConnectionQueryService {
RETURNING *
`;
return await prisma.$queryRawUnsafe(
deleteQuery,
...Object.values(conditions)
);
return await query(deleteQuery, Object.values(conditions));
default:
throw new Error(`지원하지 않는 작업입니다: ${operation}`);

39
backend-node/src/services/referenceCacheService.ts
View File

@ -1,12 +1,10 @@
import { PrismaClient } from "@prisma/client";
import { query, queryOne } from "../database/db";
import { logger } from "../utils/logger";
import {
BatchLookupRequest,
BatchLookupResponse,
} from "../types/tableManagement";
const prisma = new PrismaClient();
interface CacheEntry {
data: Map<string, any>;
expiry: number;
@ -38,11 +36,12 @@ export class ReferenceCacheService {
*/
private async getTableRowCount(tableName: string): Promise<number> {
try {
const countResult = (await prisma.$queryRawUnsafe(`
SELECT COUNT(*) as count FROM ${tableName}
`)) as Array<{ count: bigint }>;
const countResult = await query<{ count: string }>(
`SELECT COUNT(*) as count FROM ${tableName}`,
[]
);
return Number(countResult[0]?.count || 0);
return parseInt(countResult[0]?.count || "0", 10);
} catch (error) {
logger.error(`테이블 크기 조회 실패: ${tableName}`, error);
return 0;
@ -140,13 +139,14 @@ export class ReferenceCacheService {
logger.info(`참조 테이블 캐싱 시작: ${tableName}`);
// 데이터 조회
const data = (await prisma.$queryRawUnsafe(`
SELECT ${keyColumn} as key, ${displayColumn} as value
FROM ${tableName}
WHERE ${keyColumn} IS NOT NULL
AND ${displayColumn} IS NOT NULL
ORDER BY ${keyColumn}
`)) as Array<{ key: any; value: any }>;
const data = await query<{ key: any; value: any }>(
`SELECT ${keyColumn} as key, ${displayColumn} as value
FROM ${tableName}
WHERE ${keyColumn} IS NOT NULL
AND ${displayColumn} IS NOT NULL
ORDER BY ${keyColumn}`,
[]
);
const dataMap = new Map<string, any>();
for (const row of data) {
@ -301,11 +301,12 @@ export class ReferenceCacheService {
const keys = missingRequests.map((req) => req.key);
const displayColumn = missingRequests[0].displayColumn; // 같은 테이블이므로 동일
const data = (await prisma.$queryRaw`
SELECT key_column as key, ${displayColumn} as value
FROM ${tableName}
WHERE key_column = ANY(${keys})
`) as Array<{ key: any; value: any }>;
const data = await query<{ key: any; value: any }>(
`SELECT key_column as key, ${displayColumn} as value
FROM ${tableName}
WHERE key_column = ANY($1)`,
[keys]
);
// 결과를 응답에 추가
for (const row of data) {

218
backend-node/src/services/templateStandardService.ts
View File

@ -1,6 +1,4 @@
import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient();
import { query, queryOne } from "../database/db";
/**
* 템플릿 표준 관리 서비스
@ -30,42 +28,57 @@ export class TemplateStandardService {
const skip = (page - 1) * limit;
// 기본 필터 조건
const where: any = {};
// 동적 WHERE 조건 생성
const conditions: string[] = [];
const values: any[] = [];
let paramIndex = 1;
if (active && active !== "all") {
where.is_active = active;
conditions.push(`is_active = $${paramIndex++}`);
values.push(active);
}
if (category && category !== "all") {
where.category = category;
conditions.push(`category = $${paramIndex++}`);
values.push(category);
}
if (search) {
where.OR = [
{ template_name: { contains: search, mode: "insensitive" } },
{ template_name_eng: { contains: search, mode: "insensitive" } },
{ description: { contains: search, mode: "insensitive" } },
];
conditions.push(
`(template_name ILIKE $${paramIndex} OR template_name_eng ILIKE $${paramIndex} OR description ILIKE $${paramIndex})`
);
values.push(`%${search}%`);
paramIndex++;
}
// 회사별 필터링 (공개 템플릿 + 해당 회사 템플릿)
// 회사별 필터링
if (company_code) {
where.OR = [{ is_public: "Y" }, { company_code: company_code }];
conditions.push(`(is_public = 'Y' OR company_code = $${paramIndex++})`);
values.push(company_code);
} else if (is_public === "Y") {
where.is_public = "Y";
conditions.push(`is_public = $${paramIndex++}`);
values.push("Y");
}
const [templates, total] = await Promise.all([
prisma.template_standards.findMany({
where,
orderBy: [{ sort_order: "asc" }, { template_name: "asc" }],
skip,
take: limit,
}),
prisma.template_standards.count({ where }),
const whereClause =
conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
const [templates, totalResult] = await Promise.all([
query<any>(
`SELECT * FROM template_standards
${whereClause}
ORDER BY sort_order ASC, template_name ASC
LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
[...values, limit, skip]
),
queryOne<{ count: string }>(
`SELECT COUNT(*) as count FROM template_standards ${whereClause}`,
values
),
]);
const total = parseInt(totalResult?.count || "0");
return { templates, total };
}
@ -73,9 +86,10 @@ export class TemplateStandardService {
* 템플릿 상세 조회
*/
async getTemplate(templateCode: string) {
return await prisma.template_standards.findUnique({
where: { template_code: templateCode },
});
return await queryOne<any>(
`SELECT * FROM template_standards WHERE template_code = $1`,
[templateCode]
);
}
/**
@ -83,9 +97,10 @@ export class TemplateStandardService {
*/
async createTemplate(templateData: any) {
// 템플릿 코드 중복 확인
const existing = await prisma.template_standards.findUnique({
where: { template_code: templateData.template_code },
});
const existing = await queryOne<any>(
`SELECT * FROM template_standards WHERE template_code = $1`,
[templateData.template_code]
);
if (existing) {
throw new Error(
@ -93,83 +108,101 @@ export class TemplateStandardService {
);
}
return await prisma.template_standards.create({
data: {
template_code: templateData.template_code,
template_name: templateData.template_name,
template_name_eng: templateData.template_name_eng,
description: templateData.description,
category: templateData.category,
icon_name: templateData.icon_name,
default_size: templateData.default_size,
layout_config: templateData.layout_config,
preview_image: templateData.preview_image,
sort_order: templateData.sort_order || 0,
is_active: templateData.is_active || "Y",
is_public: templateData.is_public || "N",
company_code: templateData.company_code,
created_by: templateData.created_by,
updated_by: templateData.updated_by,
},
});
return await queryOne<any>(
`INSERT INTO template_standards
(template_code, template_name, template_name_eng, description, category,
icon_name, default_size, layout_config, preview_image, sort_order,
is_active, is_public, company_code, created_by, updated_by, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, NOW(), NOW())
RETURNING *`,
[
templateData.template_code,
templateData.template_name,
templateData.template_name_eng,
templateData.description,
templateData.category,
templateData.icon_name,
templateData.default_size,
templateData.layout_config,
templateData.preview_image,
templateData.sort_order || 0,
templateData.is_active || "Y",
templateData.is_public || "N",
templateData.company_code,
templateData.created_by,
templateData.updated_by,
]
);
}
/**
* 템플릿 수정
*/
async updateTemplate(templateCode: string, templateData: any) {
const updateData: any = {};
// 동적 UPDATE 쿼리 생성
const updateFields: string[] = ["updated_at = NOW()"];
const values: any[] = [];
let paramIndex = 1;
// 수정 가능한 필드들만 업데이트
if (templateData.template_name !== undefined) {
updateData.template_name = templateData.template_name;
updateFields.push(`template_name = $${paramIndex++}`);
values.push(templateData.template_name);
}
if (templateData.template_name_eng !== undefined) {
updateData.template_name_eng = templateData.template_name_eng;
updateFields.push(`template_name_eng = $${paramIndex++}`);
values.push(templateData.template_name_eng);
}
if (templateData.description !== undefined) {
updateData.description = templateData.description;
updateFields.push(`description = $${paramIndex++}`);
values.push(templateData.description);
}
if (templateData.category !== undefined) {
updateData.category = templateData.category;
updateFields.push(`category = $${paramIndex++}`);
values.push(templateData.category);
}
if (templateData.icon_name !== undefined) {
updateData.icon_name = templateData.icon_name;
updateFields.push(`icon_name = $${paramIndex++}`);
values.push(templateData.icon_name);
}
if (templateData.default_size !== undefined) {
updateData.default_size = templateData.default_size;
updateFields.push(`default_size = $${paramIndex++}`);
values.push(templateData.default_size);
}
if (templateData.layout_config !== undefined) {
updateData.layout_config = templateData.layout_config;
updateFields.push(`layout_config = $${paramIndex++}`);
values.push(templateData.layout_config);
}
if (templateData.preview_image !== undefined) {
updateData.preview_image = templateData.preview_image;
updateFields.push(`preview_image = $${paramIndex++}`);
values.push(templateData.preview_image);
}
if (templateData.sort_order !== undefined) {
updateData.sort_order = templateData.sort_order;
updateFields.push(`sort_order = $${paramIndex++}`);
values.push(templateData.sort_order);
}
if (templateData.is_active !== undefined) {
updateData.is_active = templateData.is_active;
updateFields.push(`is_active = $${paramIndex++}`);
values.push(templateData.is_active);
}
if (templateData.is_public !== undefined) {
updateData.is_public = templateData.is_public;
updateFields.push(`is_public = $${paramIndex++}`);
values.push(templateData.is_public);
}
if (templateData.updated_by !== undefined) {
updateData.updated_by = templateData.updated_by;
updateFields.push(`updated_by = $${paramIndex++}`);
values.push(templateData.updated_by);
}
updateData.updated_date = new Date();
try {
return await prisma.template_standards.update({
where: { template_code: templateCode },
data: updateData,
});
return await queryOne<any>(
`UPDATE template_standards
SET ${updateFields.join(", ")}
WHERE template_code = $${paramIndex}
RETURNING *`,
[...values, templateCode]
);
} catch (error: any) {
if (error.code === "P2025") {
return null; // 템플릿을 찾을 수 없음
}
throw error;
return null; // 템플릿을 찾을 수 없음
}
}
@ -178,15 +211,12 @@ export class TemplateStandardService {
*/
async deleteTemplate(templateCode: string) {
try {
await prisma.template_standards.delete({
where: { template_code: templateCode },
});
await query(`DELETE FROM template_standards WHERE template_code = $1`, [
templateCode,
]);
return true;
} catch (error: any) {
if (error.code === "P2025") {
return false; // 템플릿을 찾을 수 없음
}
throw error;
return false; // 템플릿을 찾을 수 없음
}
}
@ -197,13 +227,12 @@ export class TemplateStandardService {
templates: { template_code: string; sort_order: number }[]
) {
const updatePromises = templates.map((template) =>
prisma.template_standards.update({
where: { template_code: template.template_code },
data: {
sort_order: template.sort_order,
updated_date: new Date(),
},
})
query(
`UPDATE template_standards
SET sort_order = $1, updated_at = NOW()
WHERE template_code = $2`,
[template.sort_order, template.template_code]
)
);
await Promise.all(updatePromises);
@ -259,15 +288,14 @@ export class TemplateStandardService {
* 템플릿 카테고리 목록 조회
*/
async getCategories(companyCode: string) {
const categories = await prisma.template_standards.findMany({
where: {
OR: [{ is_public: "Y" }, { company_code: companyCode }],
is_active: "Y",
},
select: { category: true },
distinct: ["category"],
orderBy: { category: "asc" },
});
const categories = await query<{ category: string }>(
`SELECT DISTINCT category
FROM template_standards
WHERE (is_public = $1 OR company_code = $2)
AND is_active = $3
ORDER BY category ASC`,
["Y", companyCode, "Y"]
);
return categories.map((item) => item.category).filter(Boolean);
}

426
backend-node/src/tests/authService.test.ts
View File

@ -1,426 +0,0 @@
/**
* AuthService Raw Query 전환 단위 테스트
* Phase 1.5: 인증 서비스 테스트
*/
import { AuthService } from "../services/authService";
import { query } from "../database/db";
import { EncryptUtil } from "../utils/encryptUtil";
// 테스트 데이터
const TEST_USER = {
userId: "testuser",
password: "testpass123",
hashedPassword: "", // 테스트 전에 생성
};
describe("AuthService Raw Query 전환 테스트", () => {
// 테스트 전 준비
beforeAll(async () => {
// 테스트용 비밀번호 해시 생성
TEST_USER.hashedPassword = EncryptUtil.encrypt(TEST_USER.password);
// 테스트 사용자 생성 (이미 있으면 스킵)
try {
const existing = await query(
"SELECT user_id FROM user_info WHERE user_id = $1",
[TEST_USER.userId]
);
if (existing.length === 0) {
await query(
`INSERT INTO user_info (
user_id, user_name, user_password, company_code, locale
) VALUES ($1, $2, $3, $4, $5)`,
[
TEST_USER.userId,
"테스트 사용자",
TEST_USER.hashedPassword,
"ILSHIN",
"KR",
]
);
} else {
// 비밀번호 업데이트
await query(
"UPDATE user_info SET user_password = $1 WHERE user_id = $2",
[TEST_USER.hashedPassword, TEST_USER.userId]
);
}
} catch (error) {
console.error("테스트 사용자 생성 실패:", error);
}
});
// 테스트 후 정리
afterAll(async () => {
// 테스트 사용자 삭제 (선택적)
// await query("DELETE FROM user_info WHERE user_id = $1", [TEST_USER.userId]);
});
describe("loginPwdCheck - 로그인 비밀번호 검증", () => {
test("존재하는 사용자 로그인 성공", async () => {
const result = await AuthService.loginPwdCheck(
TEST_USER.userId,
TEST_USER.password
);
expect(result.loginResult).toBe(true);
expect(result.errorReason).toBeUndefined();
});
test("존재하지 않는 사용자 로그인 실패", async () => {
const result = await AuthService.loginPwdCheck(
"nonexistent_user_12345",
"anypassword"
);
expect(result.loginResult).toBe(false);
expect(result.errorReason).toContain("존재하지 않습니다");
});
test("잘못된 비밀번호 로그인 실패", async () => {
const result = await AuthService.loginPwdCheck(
TEST_USER.userId,
"wrongpassword123"
);
expect(result.loginResult).toBe(false);
expect(result.errorReason).toContain("일치하지 않습니다");
});
test("마스터 패스워드 로그인 성공", async () => {
const result = await AuthService.loginPwdCheck(
TEST_USER.userId,
"qlalfqjsgh11"
);
expect(result.loginResult).toBe(true);
});
test("빈 사용자 ID 처리", async () => {
const result = await AuthService.loginPwdCheck("", TEST_USER.password);
expect(result.loginResult).toBe(false);
});
test("빈 비밀번호 처리", async () => {
const result = await AuthService.loginPwdCheck(TEST_USER.userId, "");
expect(result.loginResult).toBe(false);
});
});
describe("getUserInfo - 사용자 정보 조회", () => {
test("사용자 정보 조회 성공", async () => {
const userInfo = await AuthService.getUserInfo(TEST_USER.userId);
expect(userInfo).not.toBeNull();
expect(userInfo?.userId).toBe(TEST_USER.userId);
expect(userInfo?.userName).toBeDefined();
expect(userInfo?.companyCode).toBeDefined();
expect(userInfo?.locale).toBeDefined();
});
test("사용자 정보 필드 타입 확인", async () => {
const userInfo = await AuthService.getUserInfo(TEST_USER.userId);
expect(userInfo).not.toBeNull();
expect(typeof userInfo?.userId).toBe("string");
expect(typeof userInfo?.userName).toBe("string");
expect(typeof userInfo?.companyCode).toBe("string");
expect(typeof userInfo?.locale).toBe("string");
});
test("권한 정보 조회 (있는 경우)", async () => {
const userInfo = await AuthService.getUserInfo(TEST_USER.userId);
// 권한이 없으면 authName은 빈 문자열
expect(userInfo).not.toBeNull();
if (userInfo) {
expect(typeof userInfo.authName === 'string' || userInfo.authName === undefined).toBe(true);
}
});
test("존재하지 않는 사용자 조회 실패", async () => {
const userInfo = await AuthService.getUserInfo("nonexistent_user_12345");
expect(userInfo).toBeNull();
});
test("회사 정보 기본값 확인", async () => {
const userInfo = await AuthService.getUserInfo(TEST_USER.userId);
// company_code가 없으면 기본값 "ILSHIN"
expect(userInfo?.companyCode).toBeDefined();
expect(typeof userInfo?.companyCode).toBe("string");
});
});
describe("insertLoginAccessLog - 로그인 로그 기록", () => {
test("로그인 성공 로그 기록", async () => {
await expect(
AuthService.insertLoginAccessLog({
systemName: "PMS",
userId: TEST_USER.userId,
loginResult: true,
remoteAddr: "127.0.0.1",
})
).resolves.not.toThrow();
});
test("로그인 실패 로그 기록", async () => {
await expect(
AuthService.insertLoginAccessLog({
systemName: "PMS",
userId: TEST_USER.userId,
loginResult: false,
errorMessage: "비밀번호 불일치",
remoteAddr: "127.0.0.1",
})
).resolves.not.toThrow();
});
test("로그인 로그 기록 후 DB 확인", async () => {
await AuthService.insertLoginAccessLog({
systemName: "PMS",
userId: TEST_USER.userId,
loginResult: true,
remoteAddr: "127.0.0.1",
});
// 로그가 기록되었는지 확인
const logs = await query(
`SELECT * FROM LOGIN_ACCESS_LOG
WHERE USER_ID = UPPER($1)
ORDER BY LOG_TIME DESC
LIMIT 1`,
[TEST_USER.userId]
);
expect(logs.length).toBeGreaterThan(0);
expect(logs[0].user_id).toBe(TEST_USER.userId.toUpperCase());
// login_result는 문자열 또는 불리언일 수 있음
expect(logs[0].login_result).toBeTruthy();
});
test("로그 기록 실패해도 예외 던지지 않음", async () => {
// 잘못된 데이터로 로그 기록 시도 (에러 발생하지만 프로세스 중단 안됨)
await expect(
AuthService.insertLoginAccessLog({
systemName: "PMS",
userId: TEST_USER.userId,
loginResult: true,
remoteAddr: "127.0.0.1",
})
).resolves.not.toThrow();
});
});
describe("processLogin - 전체 로그인 프로세스", () => {
test("전체 로그인 프로세스 성공", async () => {
const result = await AuthService.processLogin(
TEST_USER.userId,
TEST_USER.password,
"127.0.0.1"
);
expect(result.success).toBe(true);
expect(result.token).toBeDefined();
expect(result.userInfo).toBeDefined();
expect(result.userInfo?.userId).toBe(TEST_USER.userId);
expect(result.errorReason).toBeUndefined();
});
test("로그인 실패 시 토큰 없음", async () => {
const result = await AuthService.processLogin(
TEST_USER.userId,
"wrongpassword",
"127.0.0.1"
);
expect(result.success).toBe(false);
expect(result.token).toBeUndefined();
expect(result.userInfo).toBeUndefined();
expect(result.errorReason).toBeDefined();
});
test("존재하지 않는 사용자 로그인 실패", async () => {
const result = await AuthService.processLogin(
"nonexistent_user",
"anypassword",
"127.0.0.1"
);
expect(result.success).toBe(false);
expect(result.errorReason).toContain("존재하지 않습니다");
});
test("JWT 토큰 형식 확인", async () => {
const result = await AuthService.processLogin(
TEST_USER.userId,
TEST_USER.password,
"127.0.0.1"
);
if (result.success && result.token) {
// JWT 토큰은 3개 파트로 구성 (header.payload.signature)
const parts = result.token.split(".");
expect(parts.length).toBe(3);
}
});
test("로그인 프로세스 로그 기록 확인", async () => {
await AuthService.processLogin(
TEST_USER.userId,
TEST_USER.password,
"127.0.0.1"
);
// 로그인 로그가 기록되었는지 확인
const logs = await query(
`SELECT * FROM LOGIN_ACCESS_LOG
WHERE USER_ID = UPPER($1)
ORDER BY LOG_TIME DESC
LIMIT 1`,
[TEST_USER.userId]
);
expect(logs.length).toBeGreaterThan(0);
});
});
describe("processLogout - 로그아웃 프로세스", () => {
test("로그아웃 프로세스 성공", async () => {
await expect(
AuthService.processLogout(TEST_USER.userId, "127.0.0.1")
).resolves.not.toThrow();
});
test("로그아웃 로그 기록 확인", async () => {
await AuthService.processLogout(TEST_USER.userId, "127.0.0.1");
// 로그아웃 로그가 기록되었는지 확인
const logs = await query(
`SELECT * FROM LOGIN_ACCESS_LOG
WHERE USER_ID = UPPER($1)
AND ERROR_MESSAGE = '로그아웃'
ORDER BY LOG_TIME DESC
LIMIT 1`,
[TEST_USER.userId]
);
expect(logs.length).toBeGreaterThan(0);
expect(logs[0].error_message).toBe("로그아웃");
});
});
describe("getUserInfoFromToken - 토큰으로 사용자 정보 조회", () => {
test("유효한 토큰으로 사용자 정보 조회", async () => {
// 먼저 로그인해서 토큰 획득
const loginResult = await AuthService.processLogin(
TEST_USER.userId,
TEST_USER.password,
"127.0.0.1"
);
expect(loginResult.success).toBe(true);
expect(loginResult.token).toBeDefined();
// 토큰으로 사용자 정보 조회
const userInfo = await AuthService.getUserInfoFromToken(
loginResult.token!
);
expect(userInfo).not.toBeNull();
expect(userInfo?.userId).toBe(TEST_USER.userId);
});
test("잘못된 토큰으로 조회 실패", async () => {
const userInfo = await AuthService.getUserInfoFromToken("invalid_token");
expect(userInfo).toBeNull();
});
test("만료된 토큰으로 조회 실패", async () => {
// 만료된 토큰 시뮬레이션 (실제로는 만료 시간이 필요하므로 단순히 잘못된 토큰 사용)
const expiredToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.expired.token";
const userInfo = await AuthService.getUserInfoFromToken(expiredToken);
expect(userInfo).toBeNull();
});
});
describe("Raw Query 전환 검증", () => {
test("Prisma import가 없는지 확인", async () => {
const fs = require("fs");
const path = require("path");
const authServicePath = path.join(
__dirname,
"../services/authService.ts"
);
const content = fs.readFileSync(authServicePath, "utf8");
// Prisma import가 없어야 함
expect(content).not.toContain('import prisma from "../config/database"');
expect(content).not.toContain("import { PrismaClient }");
expect(content).not.toContain("prisma.user_info");
expect(content).not.toContain("prisma.$executeRaw");
});
test("Raw Query import 확인", async () => {
const fs = require("fs");
const path = require("path");
const authServicePath = path.join(
__dirname,
"../services/authService.ts"
);
const content = fs.readFileSync(authServicePath, "utf8");
// Raw Query import가 있어야 함
expect(content).toContain('import { query } from "../database/db"');
});
test("모든 메서드가 Raw Query 사용 확인", async () => {
const fs = require("fs");
const path = require("path");
const authServicePath = path.join(
__dirname,
"../services/authService.ts"
);
const content = fs.readFileSync(authServicePath, "utf8");
// query() 함수 호출이 있어야 함
expect(content).toContain("await query<");
expect(content).toContain("await query(");
});
});
describe("성능 테스트", () => {
test("로그인 프로세스 성능 (응답 시간 < 1초)", async () => {
const startTime = Date.now();
await AuthService.processLogin(
TEST_USER.userId,
TEST_USER.password,
"127.0.0.1"
);
const endTime = Date.now();
const elapsedTime = endTime - startTime;
expect(elapsedTime).toBeLessThan(1000); // 1초 이내
}, 2000); // 테스트 타임아웃 2초
test("사용자 정보 조회 성능 (응답 시간 < 500ms)", async () => {
const startTime = Date.now();
await AuthService.getUserInfo(TEST_USER.userId);
const endTime = Date.now();
const elapsedTime = endTime - startTime;
expect(elapsedTime).toBeLessThan(500); // 500ms 이내
}, 1000); // 테스트 타임아웃 1초
});
});

455
backend-node/src/tests/database.test.ts
View File

@ -1,455 +0,0 @@
/**
* 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

382
backend-node/src/tests/integration/auth.integration.test.ts
View File

@ -1,382 +0,0 @@
/**
* AuthService 통합 테스트
* Phase 1.5: 인증 시스템 전체 플로우 테스트
*
* 테스트 시나리오:
* 1. 로그인 → 토큰 발급
* 2. 토큰으로 API 인증
* 3. 로그아웃
*/
import request from "supertest";
import app from "../../app";
import { query } from "../../database/db";
import { EncryptUtil } from "../../utils/encryptUtil";
// 테스트 데이터
const TEST_USER = {
userId: "integration_test_user",
password: "integration_test_pass_123",
userName: "통합테스트 사용자",
};
describe("인증 시스템 통합 테스트 (Auth Integration Tests)", () => {
let authToken: string;
// 테스트 전 준비: 테스트 사용자 생성
beforeAll(async () => {
const hashedPassword = EncryptUtil.encrypt(TEST_USER.password);
try {
// 기존 사용자 확인
const existing = await query(
"SELECT user_id FROM user_info WHERE user_id = $1",
[TEST_USER.userId]
);
if (existing.length === 0) {
// 새 사용자 생성
await query(
`INSERT INTO user_info (
user_id, user_name, user_password, company_code, locale
) VALUES ($1, $2, $3, $4, $5)`,
[
TEST_USER.userId,
TEST_USER.userName,
hashedPassword,
"ILSHIN",
"KR",
]
);
} else {
// 기존 사용자 비밀번호 업데이트
await query(
"UPDATE user_info SET user_password = $1, user_name = $2 WHERE user_id = $3",
[hashedPassword, TEST_USER.userName, TEST_USER.userId]
);
}
console.log(`✅ 통합 테스트 사용자 준비 완료: ${TEST_USER.userId}`);
} catch (error) {
console.error("❌ 테스트 사용자 생성 실패:", error);
throw error;
}
});
// 테스트 후 정리 (선택적)
afterAll(async () => {
// 테스트 사용자 삭제 (필요시)
// await query("DELETE FROM user_info WHERE user_id = $1", [TEST_USER.userId]);
console.log("✅ 통합 테스트 완료");
});
describe("1. 로그인 플로우 (POST /api/auth/login)", () => {
test("✅ 올바른 자격증명으로 로그인 성공", async () => {
const response = await request(app)
.post("/api/auth/login")
.send({
userId: TEST_USER.userId,
password: TEST_USER.password,
})
.expect(200);
expect(response.body.success).toBe(true);
expect(response.body.token).toBeDefined();
expect(response.body.userInfo).toBeDefined();
expect(response.body.userInfo.userId).toBe(TEST_USER.userId);
expect(response.body.userInfo.userName).toBe(TEST_USER.userName);
// 토큰 저장 (다음 테스트에서 사용)
authToken = response.body.token;
});
test("❌ 잘못된 비밀번호로 로그인 실패", async () => {
const response = await request(app)
.post("/api/auth/login")
.send({
userId: TEST_USER.userId,
password: "wrong_password_123",
})
.expect(200);
expect(response.body.success).toBe(false);
expect(response.body.token).toBeUndefined();
expect(response.body.errorReason).toBeDefined();
expect(response.body.errorReason).toContain("일치하지 않습니다");
});
test("❌ 존재하지 않는 사용자 로그인 실패", async () => {
const response = await request(app)
.post("/api/auth/login")
.send({
userId: "nonexistent_user_999",
password: "anypassword",
})
.expect(200);
expect(response.body.success).toBe(false);
expect(response.body.token).toBeUndefined();
expect(response.body.errorReason).toContain("존재하지 않습니다");
});
test("❌ 필수 필드 누락 시 로그인 실패", async () => {
const response = await request(app)
.post("/api/auth/login")
.send({
userId: TEST_USER.userId,
// password 누락
})
.expect(400);
expect(response.body.success).toBe(false);
});
test("✅ JWT 토큰 형식 검증", () => {
expect(authToken).toBeDefined();
expect(typeof authToken).toBe("string");
// JWT는 3개 파트로 구성 (header.payload.signature)
const parts = authToken.split(".");
expect(parts.length).toBe(3);
});
});
describe("2. 토큰 검증 플로우 (GET /api/auth/verify)", () => {
test("✅ 유효한 토큰으로 검증 성공", async () => {
const response = await request(app)
.get("/api/auth/verify")
.set("Authorization", `Bearer ${authToken}`)
.expect(200);
expect(response.body.valid).toBe(true);
expect(response.body.userInfo).toBeDefined();
expect(response.body.userInfo.userId).toBe(TEST_USER.userId);
});
test("❌ 토큰 없이 요청 시 실패", async () => {
const response = await request(app).get("/api/auth/verify").expect(401);
expect(response.body.valid).toBe(false);
});
test("❌ 잘못된 토큰으로 요청 시 실패", async () => {
const response = await request(app)
.get("/api/auth/verify")
.set("Authorization", "Bearer invalid_token_12345")
.expect(401);
expect(response.body.valid).toBe(false);
});
test("❌ Bearer 없는 토큰으로 요청 시 실패", async () => {
const response = await request(app)
.get("/api/auth/verify")
.set("Authorization", authToken) // Bearer 키워드 없음
.expect(401);
expect(response.body.valid).toBe(false);
});
});
describe("3. 인증된 API 요청 플로우", () => {
test("✅ 인증된 사용자로 메뉴 조회", async () => {
const response = await request(app)
.get("/api/admin/menu")
.set("Authorization", `Bearer ${authToken}`)
.expect(200);
expect(Array.isArray(response.body)).toBe(true);
});
test("❌ 인증 없이 보호된 API 요청 실패", async () => {
const response = await request(app).get("/api/admin/menu").expect(401);
expect(response.body.success).toBe(false);
});
});
describe("4. 로그아웃 플로우 (POST /api/auth/logout)", () => {
test("✅ 로그아웃 성공", async () => {
const response = await request(app)
.post("/api/auth/logout")
.set("Authorization", `Bearer ${authToken}`)
.expect(200);
expect(response.body.success).toBe(true);
});
test("✅ 로그아웃 로그 기록 확인", async () => {
// 로그아웃 로그가 기록되었는지 확인
const logs = await query(
`SELECT * FROM LOGIN_ACCESS_LOG
WHERE USER_ID = UPPER($1)
AND ERROR_MESSAGE = '로그아웃'
ORDER BY LOG_TIME DESC
LIMIT 1`,
[TEST_USER.userId]
);
expect(logs.length).toBeGreaterThan(0);
expect(logs[0].error_message).toBe("로그아웃");
});
});
describe("5. 전체 시나리오 테스트", () => {
test("✅ 로그인 → 인증 → API 호출 → 로그아웃 전체 플로우", async () => {
// 1. 로그인
const loginResponse = await request(app)
.post("/api/auth/login")
.send({
userId: TEST_USER.userId,
password: TEST_USER.password,
})
.expect(200);
expect(loginResponse.body.success).toBe(true);
const token = loginResponse.body.token;
// 2. 토큰 검증
const verifyResponse = await request(app)
.get("/api/auth/verify")
.set("Authorization", `Bearer ${token}`)
.expect(200);
expect(verifyResponse.body.valid).toBe(true);
// 3. 보호된 API 호출
const menuResponse = await request(app)
.get("/api/admin/menu")
.set("Authorization", `Bearer ${token}`)
.expect(200);
expect(Array.isArray(menuResponse.body)).toBe(true);
// 4. 로그아웃
const logoutResponse = await request(app)
.post("/api/auth/logout")
.set("Authorization", `Bearer ${token}`)
.expect(200);
expect(logoutResponse.body.success).toBe(true);
});
});
describe("6. 에러 처리 및 예외 상황", () => {
test("❌ SQL Injection 시도 차단", async () => {
const response = await request(app)
.post("/api/auth/login")
.send({
userId: "admin' OR '1'='1",
password: "password",
})
.expect(200);
// SQL Injection이 차단되어 로그인 실패해야 함
expect(response.body.success).toBe(false);
});
test("❌ 빈 문자열로 로그인 시도", async () => {
const response = await request(app)
.post("/api/auth/login")
.send({
userId: "",
password: "",
})
.expect(400);
expect(response.body.success).toBe(false);
});
test("❌ 매우 긴 사용자 ID로 로그인 시도", async () => {
const longUserId = "a".repeat(1000);
const response = await request(app)
.post("/api/auth/login")
.send({
userId: longUserId,
password: "password",
})
.expect(200);
expect(response.body.success).toBe(false);
});
});
describe("7. 로그인 이력 확인", () => {
test("✅ 로그인 성공 이력 조회", async () => {
// 로그인 실행
await request(app).post("/api/auth/login").send({
userId: TEST_USER.userId,
password: TEST_USER.password,
});
// 로그인 이력 확인
const logs = await query(
`SELECT * FROM LOGIN_ACCESS_LOG
WHERE USER_ID = UPPER($1)
AND LOGIN_RESULT = true
ORDER BY LOG_TIME DESC
LIMIT 1`,
[TEST_USER.userId]
);
expect(logs.length).toBeGreaterThan(0);
expect(logs[0].login_result).toBeTruthy();
expect(logs[0].system_name).toBe("PMS");
});
test("✅ 로그인 실패 이력 조회", async () => {
// 로그인 실패 실행
await request(app).post("/api/auth/login").send({
userId: TEST_USER.userId,
password: "wrong_password",
});
// 로그인 실패 이력 확인
const logs = await query(
`SELECT * FROM LOGIN_ACCESS_LOG
WHERE USER_ID = UPPER($1)
AND LOGIN_RESULT = false
AND ERROR_MESSAGE IS NOT NULL
ORDER BY LOG_TIME DESC
LIMIT 1`,
[TEST_USER.userId]
);
expect(logs.length).toBeGreaterThan(0);
expect(logs[0].login_result).toBeFalsy();
expect(logs[0].error_message).toBeDefined();
});
});
describe("8. 성능 테스트", () => {
test("✅ 동시 로그인 요청 처리 (10개)", async () => {
const promises = Array.from({ length: 10 }, () =>
request(app).post("/api/auth/login").send({
userId: TEST_USER.userId,
password: TEST_USER.password,
})
);
const responses = await Promise.all(promises);
responses.forEach((response) => {
expect(response.status).toBe(200);
expect(response.body.success).toBe(true);
});
}, 10000); // 10초 타임아웃
test("✅ 로그인 응답 시간 (< 1초)", async () => {
const startTime = Date.now();
await request(app).post("/api/auth/login").send({
userId: TEST_USER.userId,
password: TEST_USER.password,
});
const endTime = Date.now();
const elapsedTime = endTime - startTime;
expect(elapsedTime).toBeLessThan(1000); // 1초 이내
}, 2000);
});
});

37
backend-node/test-db.js
View File

@ -1,37 +0,0 @@
const { Client } = require("pg");
require("dotenv/config");
async function testDatabase() {
const client = new Client({
connectionString: process.env.DATABASE_URL,
});
try {
await client.connect();
console.log("✅ 데이터베이스 연결 성공");
// 사용자 정보 조회
const userResult = await client.query(
"SELECT user_id, user_name, status FROM user_info LIMIT 5"
);
console.log("👥 사용자 정보:", userResult.rows);
// 테이블 라벨 정보 조회
const tableLabelsResult = await client.query(
"SELECT * FROM table_labels LIMIT 5"
);
console.log("🏷️ 테이블 라벨 정보:", tableLabelsResult.rows);
// 컬럼 라벨 정보 조회
const columnLabelsResult = await client.query(
"SELECT * FROM column_labels LIMIT 5"
);
console.log("📋 컬럼 라벨 정보:", columnLabelsResult.rows);
} catch (error) {
console.error("❌ 오류 발생:", error);
} finally {
await client.end();
}
}
testDatabase();

41
backend-node/test-jwt.js
View File

@ -1,41 +0,0 @@
const jwt = require("jsonwebtoken");
// JWT 설정
const JWT_SECRET = "your-super-secret-jwt-key-change-in-production";
const JWT_EXPIRES_IN = "24h";
// 테스트용 사용자 정보
const testUserInfo = {
userId: "arvin",
userName: "ARVIN",
deptName: "생산기술부",
companyCode: "ILSHIN",
};
console.log("=== JWT 토큰 테스트 ===");
console.log("사용자 정보:", testUserInfo);
// JWT 토큰 생성
const token = jwt.sign(testUserInfo, JWT_SECRET, {
expiresIn: JWT_EXPIRES_IN,
issuer: "PMS-System",
audience: "PMS-Users",
});
console.log("\n생성된 토큰:");
console.log(token);
// 토큰 검증
try {
const decoded = jwt.verify(token, JWT_SECRET);
console.log("\n토큰 검증 성공:");
console.log(decoded);
} catch (error) {
console.log("\n토큰 검증 실패:");
console.log(error.message);
}
// 토큰 디코드 (검증 없이)
const decodedWithoutVerification = jwt.decode(token);
console.log("\n토큰 디코드 (검증 없이):");
console.log(decodedWithoutVerification);

41
backend-node/test-token.js
View File

@ -1,41 +0,0 @@
const jwt = require("jsonwebtoken");
const fs = require("fs");
// JWT 설정
const JWT_SECRET = "your-super-secret-jwt-key-change-in-production";
const JWT_EXPIRES_IN = "24h";
// 테스트용 사용자 정보
const testUserInfo = {
userId: "arvin",
userName: "ARVIN",
deptName: "생산기술부",
companyCode: "ILSHIN",
};
console.log("=== JWT 토큰 생성 ===");
console.log("사용자 정보:", testUserInfo);
// JWT 토큰 생성
const token = jwt.sign(testUserInfo, JWT_SECRET, {
expiresIn: JWT_EXPIRES_IN,
issuer: "PMS-System",
audience: "PMS-Users",
});
console.log("\n생성된 토큰:");
console.log(token);
// 토큰을 파일로 저장
fs.writeFileSync("test-token.txt", token);
console.log("\n토큰이 test-token.txt 파일에 저장되었습니다.");
// 토큰 검증 테스트
try {
const decoded = jwt.verify(token, JWT_SECRET);
console.log("\n토큰 검증 성공:");
console.log(decoded);
} catch (error) {
console.log("\n토큰 검증 실패:");
console.log(error.message);
}

1
backend-node/test-token.txt
View File

@ -1 +0,0 @@
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiJhcnZpbiIsInVzZXJOYW1lIjoiQVJWSU4iLCJkZXB0TmFtZSI6IuyDneyCsOq4sOyIoOu2gCIsImNvbXBhbnlDb2RlIjoiSUxTSElOIiwiaWF0IjoxNzU1Njc1NDg1LCJleHAiOjE3NTU3NjE4ODUsImF1ZCI6IlBNUy1Vc2VycyIsImlzcyI6IlBNUy1TeXN0ZW0ifQ.9TUMD_Rq-5kVNt9EFTztM6J1cxklg8wAclRAvbj1uq0

36
backend-node/update-password.js
View File

@ -1,36 +0,0 @@
const { Client } = require("pg");
async function updatePassword() {
const client = new Client({
connectionString: process.env.DATABASE_URL,
});
try {
await client.connect();
console.log("✅ 데이터베이스 연결 성공");
// kkh 사용자의 비밀번호를 admin123으로 변경
await client.query(`
UPDATE user_info
SET user_password = 'f21b1ce8b08dc955bd4afff71b3db1fc'
WHERE user_id = 'kkh'
`);
console.log("✅ 비밀번호 변경 완료: kkh -> admin123");
// 변경 확인
const result = await client.query(`
SELECT user_id, user_name, user_password
FROM user_info
WHERE user_id = 'kkh'
`);
console.log("👤 변경된 사용자:", result.rows[0]);
} catch (error) {
console.error("❌ 오류 발생:", error);
} finally {
await client.end();
}
}
updatePassword();

274
src/database/db.ts Normal file
View File

@ -0,0 +1,274 @@
/**
* 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,
};
}
// Pool 직접 접근 (필요한 경우)
export { pool };
// 기본 익스포트 (편의성)
export default {
query,
queryOne,
transaction,
getPool,
initializePool,
closePool,
getPoolStatus,
};

128
src/services/dataflowDiagramService.ts
View File

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