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

Merge branch 'main' into lhj - 충돌 해결

This commit is contained in:
leeheejin 2025-10-01 18:01:20 +09:00
parent 6d1fe625e4 63ee0fbb5a
commit 4202a5b310
106 changed files with 13320 additions and 10514 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();

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

File diff suppressed because it is too large Load Diff

11
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",
@ -70,13 +65,13 @@
"@types/pg": "^8.15.5",
"@types/sanitize-html": "^2.9.5",
"@types/supertest": "^6.0.3",
"@types/uuid": "^10.0.0",
"@typescript-eslint/eslint-plugin": "^6.14.0",
"@typescript-eslint/parser": "^6.14.0",
"eslint": "^8.55.0",
"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();

2
backend-node/src/app.ts
View File

@ -47,6 +47,7 @@ import entityReferenceRoutes from "./routes/entityReferenceRoutes";
import externalCallRoutes from "./routes/externalCallRoutes";
import externalCallConfigRoutes from "./routes/externalCallConfigRoutes";
import dataflowExecutionRoutes from "./routes/dataflowExecutionRoutes";
import dashboardRoutes from "./routes/dashboardRoutes";
import { BatchSchedulerService } from "./services/batchSchedulerService";
// import collectionRoutes from "./routes/collectionRoutes"; // 임시 주석
// import batchRoutes from "./routes/batchRoutes"; // 임시 주석
@ -179,6 +180,7 @@ app.use("/api/entity-reference", entityReferenceRoutes);
app.use("/api/external-calls", externalCallRoutes);
app.use("/api/external-call-configs", externalCallConfigRoutes);
app.use("/api/dataflow", dataflowExecutionRoutes);
app.use("/api/dashboards", dashboardRoutes);
// app.use("/api/collections", collectionRoutes); // 임시 주석
// app.use("/api/batch", batchRoutes); // 임시 주석
// app.use('/api/users', userRoutes);

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;

436
backend-node/src/controllers/DashboardController.ts Normal file
View File

@ -0,0 +1,436 @@
import { Response } from 'express';
import { AuthenticatedRequest } from '../middleware/authMiddleware';
import { DashboardService } from '../services/DashboardService';
import { CreateDashboardRequest, UpdateDashboardRequest, DashboardListQuery } from '../types/dashboard';
import { PostgreSQLService } from '../database/PostgreSQLService';
/**
* 대시보드 컨트롤러
* - REST API 엔드포인트 처리
* - 요청 검증 및 응답 포맷팅
*/
export class DashboardController {
/**
* 대시보드 생성
* POST /api/dashboards
*/
async createDashboard(req: AuthenticatedRequest, res: Response): Promise<void> {
try {
const userId = req.user?.userId;
if (!userId) {
res.status(401).json({
success: false,
message: '인증이 필요합니다.'
});
return;
}
const { title, description, elements, isPublic = false, tags, category }: CreateDashboardRequest = req.body;
// 유효성 검증
if (!title || title.trim().length === 0) {
res.status(400).json({
success: false,
message: '대시보드 제목이 필요합니다.'
});
return;
}
if (!elements || !Array.isArray(elements)) {
res.status(400).json({
success: false,
message: '대시보드 요소 데이터가 필요합니다.'
});
return;
}
// 제목 길이 체크
if (title.length > 200) {
res.status(400).json({
success: false,
message: '제목은 200자를 초과할 수 없습니다.'
});
return;
}
// 설명 길이 체크
if (description && description.length > 1000) {
res.status(400).json({
success: false,
message: '설명은 1000자를 초과할 수 없습니다.'
});
return;
}
const dashboardData: CreateDashboardRequest = {
title: title.trim(),
description: description?.trim(),
isPublic,
elements,
tags,
category
};
// console.log('대시보드 생성 시작:', { title: dashboardData.title, userId, elementsCount: elements.length });
const savedDashboard = await DashboardService.createDashboard(dashboardData, userId);
// console.log('대시보드 생성 성공:', { id: savedDashboard.id, title: savedDashboard.title });
res.status(201).json({
success: true,
data: savedDashboard,
message: '대시보드가 성공적으로 생성되었습니다.'
});
} catch (error: any) {
// console.error('Dashboard creation error:', {
// message: error?.message,
// stack: error?.stack,
// error
// });
res.status(500).json({
success: false,
message: error?.message || '대시보드 생성 중 오류가 발생했습니다.',
error: process.env.NODE_ENV === 'development' ? error?.message : undefined
});
}
}
/**
* 대시보드 목록 조회
* GET /api/dashboards
*/
async getDashboards(req: AuthenticatedRequest, res: Response): Promise<void> {
try {
const userId = req.user?.userId;
const query: DashboardListQuery = {
page: parseInt(req.query.page as string) || 1,
limit: Math.min(parseInt(req.query.limit as string) || 20, 100), // 최대 100개
search: req.query.search as string,
category: req.query.category as string,
isPublic: req.query.isPublic === 'true' ? true : req.query.isPublic === 'false' ? false : undefined,
createdBy: req.query.createdBy as string
};
// 페이지 번호 유효성 검증
if (query.page! < 1) {
res.status(400).json({
success: false,
message: '페이지 번호는 1 이상이어야 합니다.'
});
return;
}
const result = await DashboardService.getDashboards(query, userId);
res.json({
success: true,
data: result.dashboards,
pagination: result.pagination
});
} catch (error) {
// console.error('Dashboard list error:', error);
res.status(500).json({
success: false,
message: '대시보드 목록 조회 중 오류가 발생했습니다.',
error: process.env.NODE_ENV === 'development' ? (error as Error).message : undefined
});
}
}
/**
* 대시보드 상세 조회
* GET /api/dashboards/:id
*/
async getDashboard(req: AuthenticatedRequest, res: Response): Promise<void> {
try {
const { id } = req.params;
const userId = req.user?.userId;
if (!id) {
res.status(400).json({
success: false,
message: '대시보드 ID가 필요합니다.'
});
return;
}
const dashboard = await DashboardService.getDashboardById(id, userId);
if (!dashboard) {
res.status(404).json({
success: false,
message: '대시보드를 찾을 수 없거나 접근 권한이 없습니다.'
});
return;
}
// 조회수 증가 (본인이 만든 대시보드가 아닌 경우에만)
if (userId && dashboard.createdBy !== userId) {
await DashboardService.incrementViewCount(id);
}
res.json({
success: true,
data: dashboard
});
} catch (error) {
// console.error('Dashboard get error:', error);
res.status(500).json({
success: false,
message: '대시보드 조회 중 오류가 발생했습니다.',
error: process.env.NODE_ENV === 'development' ? (error as Error).message : undefined
});
}
}
/**
* 대시보드 수정
* PUT /api/dashboards/:id
*/
async updateDashboard(req: AuthenticatedRequest, res: Response): Promise<void> {
try {
const { id } = req.params;
const userId = req.user?.userId;
if (!userId) {
res.status(401).json({
success: false,
message: '인증이 필요합니다.'
});
return;
}
if (!id) {
res.status(400).json({
success: false,
message: '대시보드 ID가 필요합니다.'
});
return;
}
const updateData: UpdateDashboardRequest = req.body;
// 유효성 검증
if (updateData.title !== undefined) {
if (typeof updateData.title !== 'string' || updateData.title.trim().length === 0) {
res.status(400).json({
success: false,
message: '올바른 제목을 입력해주세요.'
});
return;
}
if (updateData.title.length > 200) {
res.status(400).json({
success: false,
message: '제목은 200자를 초과할 수 없습니다.'
});
return;
}
updateData.title = updateData.title.trim();
}
if (updateData.description !== undefined && updateData.description && updateData.description.length > 1000) {
res.status(400).json({
success: false,
message: '설명은 1000자를 초과할 수 없습니다.'
});
return;
}
const updatedDashboard = await DashboardService.updateDashboard(id, updateData, userId);
if (!updatedDashboard) {
res.status(404).json({
success: false,
message: '대시보드를 찾을 수 없거나 수정 권한이 없습니다.'
});
return;
}
res.json({
success: true,
data: updatedDashboard,
message: '대시보드가 성공적으로 수정되었습니다.'
});
} catch (error) {
// console.error('Dashboard update error:', error);
if ((error as Error).message.includes('권한이 없습니다')) {
res.status(403).json({
success: false,
message: (error as Error).message
});
return;
}
res.status(500).json({
success: false,
message: '대시보드 수정 중 오류가 발생했습니다.',
error: process.env.NODE_ENV === 'development' ? (error as Error).message : undefined
});
}
}
/**
* 대시보드 삭제
* DELETE /api/dashboards/:id
*/
async deleteDashboard(req: AuthenticatedRequest, res: Response): Promise<void> {
try {
const { id } = req.params;
const userId = req.user?.userId;
if (!userId) {
res.status(401).json({
success: false,
message: '인증이 필요합니다.'
});
return;
}
if (!id) {
res.status(400).json({
success: false,
message: '대시보드 ID가 필요합니다.'
});
return;
}
const deleted = await DashboardService.deleteDashboard(id, userId);
if (!deleted) {
res.status(404).json({
success: false,
message: '대시보드를 찾을 수 없거나 삭제 권한이 없습니다.'
});
return;
}
res.json({
success: true,
message: '대시보드가 성공적으로 삭제되었습니다.'
});
} catch (error) {
// console.error('Dashboard delete error:', error);
res.status(500).json({
success: false,
message: '대시보드 삭제 중 오류가 발생했습니다.',
error: process.env.NODE_ENV === 'development' ? (error as Error).message : undefined
});
}
}
/**
* 내 대시보드 목록 조회
* GET /api/dashboards/my
*/
async getMyDashboards(req: AuthenticatedRequest, res: Response): Promise<void> {
try {
const userId = req.user?.userId;
if (!userId) {
res.status(401).json({
success: false,
message: '인증이 필요합니다.'
});
return;
}
const query: DashboardListQuery = {
page: parseInt(req.query.page as string) || 1,
limit: Math.min(parseInt(req.query.limit as string) || 20, 100),
search: req.query.search as string,
category: req.query.category as string,
createdBy: userId // 본인이 만든 대시보드만
};
const result = await DashboardService.getDashboards(query, userId);
res.json({
success: true,
data: result.dashboards,
pagination: result.pagination
});
} catch (error) {
// console.error('My dashboards error:', error);
res.status(500).json({
success: false,
message: '내 대시보드 목록 조회 중 오류가 발생했습니다.',
error: process.env.NODE_ENV === 'development' ? (error as Error).message : undefined
});
}
}
/**
* 쿼리 실행
* POST /api/dashboards/execute-query
*/
async executeQuery(req: AuthenticatedRequest, res: Response): Promise<void> {
try {
// 개발용으로 인증 체크 제거
// const userId = req.user?.userId;
// if (!userId) {
// res.status(401).json({
// success: false,
// message: '인증이 필요합니다.'
// });
// return;
// }
const { query } = req.body;
// 유효성 검증
if (!query || typeof query !== 'string' || query.trim().length === 0) {
res.status(400).json({
success: false,
message: '쿼리가 필요합니다.'
});
return;
}
// SQL 인젝션 방지를 위한 기본적인 검증
const trimmedQuery = query.trim().toLowerCase();
if (!trimmedQuery.startsWith('select')) {
res.status(400).json({
success: false,
message: 'SELECT 쿼리만 허용됩니다.'
});
return;
}
// 쿼리 실행
const result = await PostgreSQLService.query(query.trim());
// 결과 변환
const columns = result.fields?.map(field => field.name) || [];
const rows = result.rows || [];
res.status(200).json({
success: true,
data: {
columns,
rows,
rowCount: rows.length
},
message: '쿼리가 성공적으로 실행되었습니다.'
});
} catch (error) {
// console.error('Query execution error:', error);
res.status(500).json({
success: false,
message: '쿼리 실행 중 오류가 발생했습니다.',
error: process.env.NODE_ENV === 'development' ? (error as Error).message : '쿼리 실행 오류'
});
}
}
}

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") ||

210
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";
/**
@ -29,13 +29,23 @@ export async function executeDataAction(
// 연결 정보에 따라 다른 데이터베이스에 저장
let result;
if (connection && connection.id !== 0) {
// 외부 데이터베이스 연결
result = await executeExternalDatabaseAction(tableName, data, actionType, connection);
result = await executeExternalDatabaseAction(
tableName,
data,
actionType,
connection
);
} else {
// 메인 데이터베이스 (현재 시스템)
result = await executeMainDatabaseAction(tableName, data, actionType, companyCode);
result = await executeMainDatabaseAction(
tableName,
data,
actionType,
companyCode
);
}
logger.info(`데이터 액션 실행 완료: ${actionType} on ${tableName}`, result);
@ -45,7 +55,6 @@ export async function executeDataAction(
message: `데이터 액션 실행 완료: ${actionType}`,
data: result,
});
} catch (error: any) {
logger.error("데이터 액션 실행 실패:", error);
res.status(500).json({
@ -73,13 +82,13 @@ async function executeMainDatabaseAction(
};
switch (actionType.toLowerCase()) {
case 'insert':
case "insert":
return await executeInsert(tableName, dataWithCompany);
case 'update':
case "update":
return await executeUpdate(tableName, dataWithCompany);
case 'upsert':
case "upsert":
return await executeUpsert(tableName, dataWithCompany);
case 'delete':
case "delete":
return await executeDelete(tableName, dataWithCompany);
default:
throw new Error(`지원하지 않는 액션 타입: ${actionType}`);
@ -91,7 +100,7 @@ async function executeMainDatabaseAction(
}
/**
* 외부 데이터베이스에서 데이터 액션 실행 (보안상 비활성화)
* 외부 데이터베이스에서 데이터 액션 실행
*/
async function executeExternalDatabaseAction(
tableName: string,
@ -99,32 +108,80 @@ async function executeExternalDatabaseAction(
actionType: string,
connection: any
): Promise<any> {
// 보안상 외부 DB에 대한 모든 데이터 변경 작업은 비활성화
throw new Error(`보안상 외부 데이터베이스에 대한 ${actionType.toUpperCase()} 작업은 허용되지 않습니다. SELECT 쿼리만 사용해주세요.`);
try {
logger.info(
`외부 DB 액션 실행: ${connection.name} (${connection.host}:${connection.port})`
);
logger.info(`테이블: ${tableName}, 액션: ${actionType}`, data);
// 🔥 실제 외부 DB 연결 및 실행 로직 구현
const { MultiConnectionQueryService } = await import(
"../services/multiConnectionQueryService"
);
const queryService = new MultiConnectionQueryService();
let result;
switch (actionType.toLowerCase()) {
case "insert":
result = await queryService.insertDataToConnection(
connection.id,
tableName,
data
);
logger.info(`외부 DB INSERT 성공:`, result);
break;
case "update":
// TODO: UPDATE 로직 구현 (조건 필요)
throw new Error(
"UPDATE 액션은 아직 지원되지 않습니다. 조건 설정이 필요합니다."
);
case "delete":
// TODO: DELETE 로직 구현 (조건 필요)
throw new Error(
"DELETE 액션은 아직 지원되지 않습니다. 조건 설정이 필요합니다."
);
default:
throw new Error(`지원하지 않는 액션 타입: ${actionType}`);
}
return {
success: true,
message: `외부 DB 액션 실행 완료: ${actionType} on ${tableName}`,
connection: connection.name,
data: result,
affectedRows: 1,
};
} catch (error) {
logger.error(`외부 DB 액션 실행 오류 (${actionType}):`, error);
throw error;
}
}
/**
* INSERT 실행
*/
async function executeInsert(tableName: string, data: Record<string, any>): Promise<any> {
async function executeInsert(
tableName: string,
data: Record<string, any>
): Promise<any> {
try {
// 동적 테이블 접근을 위한 raw query 사용
const columns = Object.keys(data).join(', ');
const columns = Object.keys(data).join(", ");
const values = Object.values(data);
const placeholders = values.map((_, index) => `$${index + 1}`).join(', ');
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',
action: "insert",
tableName,
data: result,
affectedRows: Array.isArray(result) ? result.length : 1,
affectedRows: result.length,
};
} catch (error) {
logger.error(`INSERT 실행 오류:`, error);
@ -135,32 +192,79 @@ async function executeInsert(tableName: string, data: Record<string, any>): Prom
/**
* UPDATE 실행
*/
async function executeUpdate(tableName: string, data: Record<string, any>): Promise<any> {
async function executeUpdate(
tableName: string,
data: Record<string, any>
): Promise<any> {
try {
// ID 또는 기본키를 기준으로 업데이트
const { id, ...updateData } = data;
if (!id) {
throw new Error('UPDATE를 위한 ID가 필요합니다');
logger.info(`UPDATE 액션 시작:`, { tableName, receivedData: data });
// 1. 테이블의 실제 기본키 조회
const primaryKeyQuery = `
SELECT a.attname as column_name
FROM pg_index i
JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
WHERE i.indrelid = $1::regclass AND i.indisprimary
`;
const pkResult = await query<{ column_name: string }>(primaryKeyQuery, [
tableName,
]);
if (!pkResult || pkResult.length === 0) {
throw new Error(`테이블 ${tableName}의 기본키를 찾을 수 없습니다`);
}
const primaryKeyColumn = pkResult[0].column_name;
logger.info(`테이블 ${tableName}의 기본키:`, primaryKeyColumn);
// 2. 기본키 값 추출
const primaryKeyValue = data[primaryKeyColumn];
if (!primaryKeyValue && primaryKeyValue !== 0) {
logger.error(`UPDATE 실패: 기본키 값이 없음`, {
primaryKeyColumn,
receivedData: data,
availableKeys: Object.keys(data),
});
throw new Error(
`UPDATE를 위한 기본키 값이 필요합니다 (${primaryKeyColumn})`
);
}
// 3. 업데이트할 데이터에서 기본키 제외
const updateData = { ...data };
delete updateData[primaryKeyColumn];
logger.info(`UPDATE 데이터 준비:`, {
primaryKeyColumn,
primaryKeyValue,
updateFields: Object.keys(updateData),
});
// 4. 동적 UPDATE 쿼리 생성
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] });
.join(", ");
const values = Object.values(updateData);
const updateQuery = `UPDATE ${tableName} SET ${setClause} WHERE ${primaryKeyColumn} = $${values.length + 1} RETURNING *`;
logger.info(`UPDATE 쿼리 실행:`, {
query: updateQuery,
values: [...values, primaryKeyValue],
});
const result = await query<any>(updateQuery, [...values, primaryKeyValue]);
logger.info(`UPDATE 성공:`, { affectedRows: result.length });
const result = await prisma.$queryRawUnsafe(query, ...values, id);
return {
success: true,
action: 'update',
action: "update",
tableName,
data: result,
affectedRows: Array.isArray(result) ? result.length : 1,
affectedRows: result.length,
};
} catch (error) {
logger.error(`UPDATE 실행 오류:`, error);
@ -171,7 +275,10 @@ async function executeUpdate(tableName: string, data: Record<string, any>): Prom
/**
* UPSERT 실행
*/
async function executeUpsert(tableName: string, data: Record<string, any>): Promise<any> {
async function executeUpsert(
tableName: string,
data: Record<string, any>
): Promise<any> {
try {
// 먼저 INSERT를 시도하고, 실패하면 UPDATE
try {
@ -190,26 +297,29 @@ async function executeUpsert(tableName: string, data: Record<string, any>): Prom
/**
* DELETE 실행
*/
async function executeDelete(tableName: string, data: Record<string, any>): Promise<any> {
async function executeDelete(
tableName: string,
data: Record<string, any>
): Promise<any> {
try {
const { id } = data;
if (!id) {
throw new Error('DELETE를 위한 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',
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({

130
backend-node/src/database/OracleConnector.ts
View File

@ -1,7 +1,11 @@
// @ts-ignore
import * as oracledb from 'oracledb';
import { DatabaseConnector, ConnectionConfig, QueryResult } from '../interfaces/DatabaseConnector';
import { ConnectionTestResult, TableInfo } from '../types/externalDbTypes';
import * as oracledb from "oracledb";
import {
DatabaseConnector,
ConnectionConfig,
QueryResult,
} from "../interfaces/DatabaseConnector";
import { ConnectionTestResult, TableInfo } from "../types/externalDbTypes";
export class OracleConnector implements DatabaseConnector {
private connection: oracledb.Connection | null = null;
@ -9,7 +13,7 @@ export class OracleConnector implements DatabaseConnector {
constructor(config: ConnectionConfig) {
this.config = config;
// Oracle XE 21c 특화 설정
// oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT;
// oracledb.autoCommit = true;
@ -19,31 +23,31 @@ export class OracleConnector implements DatabaseConnector {
try {
// Oracle XE 21c 연결 문자열 구성
const connectionString = this.buildConnectionString();
const connectionConfig: any = {
user: this.config.user,
password: this.config.password,
connectString: connectionString
connectString: connectionString,
};
this.connection = await oracledb.getConnection(connectionConfig);
console.log('Oracle XE 21c 연결 성공');
console.log("Oracle XE 21c 연결 성공");
} catch (error: any) {
console.error('Oracle XE 21c 연결 실패:', error);
console.error("Oracle XE 21c 연결 실패:", error);
throw new Error(`Oracle 연결 실패: ${error.message}`);
}
}
private buildConnectionString(): string {
const { host, port, database } = this.config;
// Oracle XE 21c는 기본적으로 XE 서비스명을 사용
// 다양한 연결 문자열 형식 지원
if (database.includes('/') || database.includes(':')) {
if (database.includes("/") || database.includes(":")) {
// 이미 완전한 연결 문자열인 경우
return database;
}
// Oracle XE 21c 표준 형식
return `${host}:${port}/${database}`;
}
@ -53,9 +57,9 @@ export class OracleConnector implements DatabaseConnector {
try {
await this.connection.close();
this.connection = null;
console.log('Oracle 연결 해제됨');
console.log("Oracle 연결 해제됨");
} catch (error: any) {
console.error('Oracle 연결 해제 실패:', error);
console.error("Oracle 연결 해제 실패:", error);
}
}
}
@ -65,28 +69,28 @@ export class OracleConnector implements DatabaseConnector {
if (!this.connection) {
await this.connect();
}
// Oracle XE 21c 버전 확인 쿼리
const result = await this.connection!.execute(
'SELECT BANNER FROM V$VERSION WHERE BANNER LIKE \'Oracle%\''
"SELECT BANNER FROM V$VERSION WHERE BANNER LIKE 'Oracle%'"
);
console.log('Oracle 버전:', result.rows);
console.log("Oracle 버전:", result.rows);
return {
success: true,
message: '연결 성공',
message: "연결 성공",
details: {
server_version: (result.rows as any)?.[0]?.BANNER || 'Unknown'
}
server_version: (result.rows as any)?.[0]?.BANNER || "Unknown",
},
};
} catch (error: any) {
console.error('Oracle 연결 테스트 실패:', error);
console.error("Oracle 연결 테스트 실패:", error);
return {
success: false,
message: '연결 실패',
message: "연결 실패",
details: {
server_version: error.message
}
server_version: error.message,
},
};
}
}
@ -98,52 +102,64 @@ export class OracleConnector implements DatabaseConnector {
try {
const startTime = Date.now();
// 쿼리 타입 확인 (DML인지 SELECT인지)
const isDML = /^\s*(INSERT|UPDATE|DELETE|MERGE)/i.test(query);
// Oracle XE 21c 쿼리 실행 옵션
const options: any = {
outFormat: (oracledb as any).OUT_FORMAT_OBJECT, // OBJECT format
maxRows: 10000, // XE 제한 고려
fetchArraySize: 100
fetchArraySize: 100,
autoCommit: isDML, // ✅ DML 쿼리는 자동 커밋
};
console.log("Oracle 쿼리 실행:", {
query: query.substring(0, 100) + "...",
isDML,
autoCommit: options.autoCommit,
});
const result = await this.connection!.execute(query, params, options);
const executionTime = Date.now() - startTime;
console.log('Oracle 쿼리 실행 결과:', {
console.log("Oracle 쿼리 실행 결과:", {
query,
rowCount: result.rows?.length || 0,
rowsAffected: result.rowsAffected,
metaData: result.metaData?.length || 0,
executionTime: `${executionTime}ms`,
actualRows: result.rows,
metaDataInfo: result.metaData
metaDataInfo: result.metaData,
autoCommit: options.autoCommit,
});
return {
rows: result.rows || [],
rowCount: result.rowsAffected || (result.rows?.length || 0),
fields: this.extractFieldInfo(result.metaData || [])
rowCount: result.rowsAffected || result.rows?.length || 0,
fields: this.extractFieldInfo(result.metaData || []),
};
} catch (error: any) {
console.error('Oracle 쿼리 실행 실패:', error);
console.error("Oracle 쿼리 실행 실패:", error);
throw new Error(`쿼리 실행 실패: ${error.message}`);
}
}
private extractFieldInfo(metaData: any[]): any[] {
return metaData.map(field => ({
return metaData.map((field) => ({
name: field.name,
type: this.mapOracleType(field.dbType),
length: field.precision || field.byteSize,
nullable: field.nullable
nullable: field.nullable,
}));
}
private mapOracleType(oracleType: any): string {
// Oracle XE 21c 타입 매핑 (간단한 방식)
if (typeof oracleType === 'string') {
if (typeof oracleType === "string") {
return oracleType;
}
return 'UNKNOWN';
return "UNKNOWN";
}
async getTables(): Promise<TableInfo[]> {
@ -155,22 +171,21 @@ export class OracleConnector implements DatabaseConnector {
ORDER BY table_name
`;
console.log('Oracle 테이블 조회 시작 - 사용자:', this.config.user);
console.log("Oracle 테이블 조회 시작 - 사용자:", this.config.user);
const result = await this.executeQuery(query);
console.log('사용자 스키마 테이블 조회 결과:', result.rows);
console.log("사용자 스키마 테이블 조회 결과:", result.rows);
const tables = result.rows.map((row: any) => ({
table_name: row.TABLE_NAME,
columns: [],
description: null
description: null,
}));
console.log(`총 ${tables.length}개의 사용자 테이블을 찾았습니다.`);
return tables;
} catch (error: any) {
console.error('Oracle 테이블 목록 조회 실패:', error);
console.error("Oracle 테이블 목록 조회 실패:", error);
throw new Error(`테이블 목록 조회 실패: ${error.message}`);
}
}
@ -178,7 +193,7 @@ export class OracleConnector implements DatabaseConnector {
async getColumns(tableName: string): Promise<any[]> {
try {
console.log(`[OracleConnector] getColumns 호출: tableName=${tableName}`);
const query = `
SELECT
column_name,
@ -192,41 +207,44 @@ export class OracleConnector implements DatabaseConnector {
WHERE table_name = UPPER(:tableName)
ORDER BY column_id
`;
console.log(`[OracleConnector] 쿼리 실행 시작: ${query}`);
const result = await this.executeQuery(query, [tableName]);
console.log(`[OracleConnector] 쿼리 결과:`, result.rows);
console.log(`[OracleConnector] 결과 개수:`, result.rows ? result.rows.length : 'null/undefined');
console.log(
`[OracleConnector] 결과 개수:`,
result.rows ? result.rows.length : "null/undefined"
);
const mappedResult = result.rows.map((row: any) => ({
column_name: row.COLUMN_NAME,
data_type: this.formatOracleDataType(row),
is_nullable: row.NULLABLE === 'Y' ? 'YES' : 'NO',
column_default: row.DATA_DEFAULT
is_nullable: row.NULLABLE === "Y" ? "YES" : "NO",
column_default: row.DATA_DEFAULT,
}));
console.log(`[OracleConnector] 매핑된 결과:`, mappedResult);
return mappedResult;
} catch (error: any) {
console.error('[OracleConnector] getColumns 오류:', error);
console.error("[OracleConnector] getColumns 오류:", error);
throw new Error(`테이블 컬럼 조회 실패: ${error.message}`);
}
}
private formatOracleDataType(row: any): string {
const { DATA_TYPE, DATA_LENGTH, DATA_PRECISION, DATA_SCALE } = row;
switch (DATA_TYPE) {
case 'NUMBER':
case "NUMBER":
if (DATA_PRECISION && DATA_SCALE !== null) {
return `NUMBER(${DATA_PRECISION},${DATA_SCALE})`;
} else if (DATA_PRECISION) {
return `NUMBER(${DATA_PRECISION})`;
}
return 'NUMBER';
case 'VARCHAR2':
case 'CHAR':
return "NUMBER";
case "VARCHAR2":
case "CHAR":
return `${DATA_TYPE}(${DATA_LENGTH})`;
default:
return DATA_TYPE;

127
backend-node/src/database/PostgreSQLService.ts Normal file
View File

@ -0,0 +1,127 @@
import { Pool, PoolClient, QueryResult } from 'pg';
import config from '../config/environment';
/**
* PostgreSQL Raw Query 서비스
* Prisma 대신 직접 pg 라이브러리를 사용
*/
export class PostgreSQLService {
private static pool: Pool;
/**
* 데이터베이스 연결 풀 초기화
*/
static initialize() {
if (!this.pool) {
this.pool = new Pool({
connectionString: config.databaseUrl,
max: 20, // 최대 연결 수
idleTimeoutMillis: 30000,
connectionTimeoutMillis: 2000,
});
// 연결 풀 이벤트 리스너
this.pool.on('connect', () => {
console.log('🔗 PostgreSQL 연결 성공');
});
this.pool.on('error', (err) => {
console.error('❌ PostgreSQL 연결 오류:', err);
});
}
}
/**
* 연결 풀 가져오기
*/
static getPool(): Pool {
if (!this.pool) {
this.initialize();
}
return this.pool;
}
/**
* 단일 쿼리 실행
*/
static async query(text: string, params?: any[]): Promise<QueryResult> {
const pool = this.getPool();
const start = Date.now();
try {
const result = await pool.query(text, params);
const duration = Date.now() - start;
if (config.debug) {
console.log('🔍 Query executed:', { text, duration: `${duration}ms`, rows: result.rowCount });
}
return result;
} catch (error) {
console.error('❌ Query error:', { text, params, error });
throw error;
}
}
/**
* 트랜잭션 실행
*/
static async transaction<T>(callback: (client: PoolClient) => Promise<T>): Promise<T> {
const pool = this.getPool();
const client = await pool.connect();
try {
await client.query('BEGIN');
const result = await callback(client);
await client.query('COMMIT');
return result;
} catch (error) {
await client.query('ROLLBACK');
throw error;
} finally {
client.release();
}
}
/**
* 연결 테스트
*/
static async testConnection(): Promise<boolean> {
try {
const result = await this.query('SELECT NOW() as current_time');
console.log('✅ PostgreSQL 연결 테스트 성공:', result.rows[0]);
return true;
} catch (error) {
console.error('❌ PostgreSQL 연결 테스트 실패:', error);
return false;
}
}
/**
* 연결 풀 종료
*/
static async close(): Promise<void> {
if (this.pool) {
await this.pool.end();
console.log('🔒 PostgreSQL 연결 풀 종료');
}
}
}
// 애플리케이션 시작 시 초기화
PostgreSQLService.initialize();
// 프로세스 종료 시 연결 정리
process.on('SIGINT', async () => {
await PostgreSQLService.close();
process.exit(0);
});
process.on('SIGTERM', async () => {
await PostgreSQLService.close();
process.exit(0);
});
process.on('beforeExit', async () => {
await PostgreSQLService.close();
});

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,

37
backend-node/src/routes/dashboardRoutes.ts Normal file
View File

@ -0,0 +1,37 @@
import { Router } from 'express';
import { DashboardController } from '../controllers/DashboardController';
import { authenticateToken } from '../middleware/authMiddleware';
const router = Router();
const dashboardController = new DashboardController();
/**
* 대시보드 API 라우트
*
* 모든 엔드포인트는 인증이 필요하지만,
* 공개 대시보드 조회는 인증 없이도 가능
*/
// 공개 대시보드 목록 조회 (인증 불필요)
router.get('/public', dashboardController.getDashboards.bind(dashboardController));
// 공개 대시보드 상세 조회 (인증 불필요)
router.get('/public/:id', dashboardController.getDashboard.bind(dashboardController));
// 쿼리 실행 (인증 불필요 - 개발용)
router.post('/execute-query', dashboardController.executeQuery.bind(dashboardController));
// 인증이 필요한 라우트들
router.use(authenticateToken);
// 내 대시보드 목록 조회
router.get('/my', dashboardController.getMyDashboards.bind(dashboardController));
// 대시보드 CRUD
router.post('/', dashboardController.createDashboard.bind(dashboardController));
router.get('/', dashboardController.getDashboards.bind(dashboardController));
router.get('/:id', dashboardController.getDashboard.bind(dashboardController));
router.put('/:id', dashboardController.updateDashboard.bind(dashboardController));
router.delete('/:id', dashboardController.deleteDashboard.bind(dashboardController));
export default router;

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,

534
backend-node/src/services/DashboardService.ts Normal file
View File

@ -0,0 +1,534 @@
import { v4 as uuidv4 } from 'uuid';
import { PostgreSQLService } from '../database/PostgreSQLService';
import {
Dashboard,
DashboardElement,
CreateDashboardRequest,
UpdateDashboardRequest,
DashboardListQuery
} from '../types/dashboard';
/**
* 대시보드 서비스 - Raw Query 방식
* PostgreSQL 직접 연결을 통한 CRUD 작업
*/
export class DashboardService {
/**
* 대시보드 생성
*/
static async createDashboard(data: CreateDashboardRequest, userId: string): Promise<Dashboard> {
const dashboardId = uuidv4();
const now = new Date();
try {
// 트랜잭션으로 대시보드와 요소들을 함께 생성
const result = await PostgreSQLService.transaction(async (client) => {
// 1. 대시보드 메인 정보 저장
await client.query(`
INSERT INTO dashboards (
id, title, description, is_public, created_by,
created_at, updated_at, tags, category, view_count
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
`, [
dashboardId,
data.title,
data.description || null,
data.isPublic || false,
userId,
now,
now,
JSON.stringify(data.tags || []),
data.category || null,
0
]);
// 2. 대시보드 요소들 저장
if (data.elements && data.elements.length > 0) {
for (let i = 0; i < data.elements.length; i++) {
const element = data.elements[i];
const elementId = uuidv4(); // 항상 새로운 UUID 생성
await client.query(`
INSERT INTO dashboard_elements (
id, dashboard_id, element_type, element_subtype,
position_x, position_y, width, height,
title, content, data_source_config, chart_config,
display_order, created_at, updated_at
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
`, [
elementId,
dashboardId,
element.type,
element.subtype,
element.position.x,
element.position.y,
element.size.width,
element.size.height,
element.title,
element.content || null,
JSON.stringify(element.dataSource || {}),
JSON.stringify(element.chartConfig || {}),
i,
now,
now
]);
}
}
return dashboardId;
});
// 생성된 대시보드 반환
try {
const dashboard = await this.getDashboardById(dashboardId, userId);
if (!dashboard) {
console.error('대시보드 생성은 성공했으나 조회에 실패:', dashboardId);
// 생성은 성공했으므로 기본 정보만이라도 반환
return {
id: dashboardId,
title: data.title,
description: data.description,
thumbnailUrl: undefined,
isPublic: data.isPublic || false,
createdBy: userId,
createdAt: now.toISOString(),
updatedAt: now.toISOString(),
tags: data.tags || [],
category: data.category,
viewCount: 0,
elements: data.elements || []
};
}
return dashboard;
} catch (fetchError) {
console.error('생성된 대시보드 조회 중 오류:', fetchError);
// 생성은 성공했으므로 기본 정보 반환
return {
id: dashboardId,
title: data.title,
description: data.description,
thumbnailUrl: undefined,
isPublic: data.isPublic || false,
createdBy: userId,
createdAt: now.toISOString(),
updatedAt: now.toISOString(),
tags: data.tags || [],
category: data.category,
viewCount: 0,
elements: data.elements || []
};
}
} catch (error) {
console.error('Dashboard creation error:', error);
throw error;
}
}
/**
* 대시보드 목록 조회
*/
static async getDashboards(query: DashboardListQuery, userId?: string) {
const {
page = 1,
limit = 20,
search,
category,
isPublic,
createdBy
} = query;
const offset = (page - 1) * limit;
try {
// 기본 WHERE 조건
let whereConditions = ['d.deleted_at IS NULL'];
let params: any[] = [];
let paramIndex = 1;
// 권한 필터링
if (userId) {
whereConditions.push(`(d.created_by = $${paramIndex} OR d.is_public = true)`);
params.push(userId);
paramIndex++;
} else {
whereConditions.push('d.is_public = true');
}
// 검색 조건
if (search) {
whereConditions.push(`(d.title ILIKE $${paramIndex} OR d.description ILIKE $${paramIndex + 1})`);
params.push(`%${search}%`, `%${search}%`);
paramIndex += 2;
}
// 카테고리 필터
if (category) {
whereConditions.push(`d.category = $${paramIndex}`);
params.push(category);
paramIndex++;
}
// 공개/비공개 필터
if (typeof isPublic === 'boolean') {
whereConditions.push(`d.is_public = $${paramIndex}`);
params.push(isPublic);
paramIndex++;
}
// 작성자 필터
if (createdBy) {
whereConditions.push(`d.created_by = $${paramIndex}`);
params.push(createdBy);
paramIndex++;
}
const whereClause = whereConditions.join(' AND ');
// 대시보드 목록 조회 (users 테이블 조인 제거)
const dashboardQuery = `
SELECT
d.id,
d.title,
d.description,
d.thumbnail_url,
d.is_public,
d.created_by,
d.created_at,
d.updated_at,
d.tags,
d.category,
d.view_count,
COUNT(de.id) as elements_count
FROM dashboards d
LEFT JOIN dashboard_elements de ON d.id = de.dashboard_id
WHERE ${whereClause}
GROUP BY d.id, d.title, d.description, d.thumbnail_url, d.is_public,
d.created_by, d.created_at, d.updated_at, d.tags, d.category,
d.view_count
ORDER BY d.updated_at DESC
LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
`;
const dashboardResult = await PostgreSQLService.query(
dashboardQuery,
[...params, limit, offset]
);
// 전체 개수 조회
const countQuery = `
SELECT COUNT(DISTINCT d.id) as total
FROM dashboards d
WHERE ${whereClause}
`;
const countResult = await PostgreSQLService.query(countQuery, params);
const total = parseInt(countResult.rows[0]?.total || '0');
return {
dashboards: dashboardResult.rows.map((row: any) => ({
id: row.id,
title: row.title,
description: row.description,
thumbnailUrl: row.thumbnail_url,
isPublic: row.is_public,
createdBy: row.created_by,
createdAt: row.created_at,
updatedAt: row.updated_at,
tags: JSON.parse(row.tags || '[]'),
category: row.category,
viewCount: parseInt(row.view_count || '0'),
elementsCount: parseInt(row.elements_count || '0')
})),
pagination: {
page,
limit,
total,
totalPages: Math.ceil(total / limit)
}
};
} catch (error) {
console.error('Dashboard list error:', error);
throw error;
}
}
/**
* 대시보드 상세 조회
*/
static async getDashboardById(dashboardId: string, userId?: string): Promise<Dashboard | null> {
try {
// 1. 대시보드 기본 정보 조회 (권한 체크 포함)
let dashboardQuery: string;
let dashboardParams: any[];
if (userId) {
dashboardQuery = `
SELECT d.*
FROM dashboards d
WHERE d.id = $1 AND d.deleted_at IS NULL
AND (d.created_by = $2 OR d.is_public = true)
`;
dashboardParams = [dashboardId, userId];
} else {
dashboardQuery = `
SELECT d.*
FROM dashboards d
WHERE d.id = $1 AND d.deleted_at IS NULL
AND d.is_public = true
`;
dashboardParams = [dashboardId];
}
const dashboardResult = await PostgreSQLService.query(dashboardQuery, dashboardParams);
if (dashboardResult.rows.length === 0) {
return null;
}
const dashboard = dashboardResult.rows[0];
// 2. 대시보드 요소들 조회
const elementsQuery = `
SELECT * FROM dashboard_elements
WHERE dashboard_id = $1
ORDER BY display_order ASC
`;
const elementsResult = await PostgreSQLService.query(elementsQuery, [dashboardId]);
// 3. 요소 데이터 변환
const elements: DashboardElement[] = elementsResult.rows.map((row: any) => ({
id: row.id,
type: row.element_type,
subtype: row.element_subtype,
position: {
x: row.position_x,
y: row.position_y
},
size: {
width: row.width,
height: row.height
},
title: row.title,
content: row.content,
dataSource: JSON.parse(row.data_source_config || '{}'),
chartConfig: JSON.parse(row.chart_config || '{}')
}));
return {
id: dashboard.id,
title: dashboard.title,
description: dashboard.description,
thumbnailUrl: dashboard.thumbnail_url,
isPublic: dashboard.is_public,
createdBy: dashboard.created_by,
createdAt: dashboard.created_at,
updatedAt: dashboard.updated_at,
tags: JSON.parse(dashboard.tags || '[]'),
category: dashboard.category,
viewCount: parseInt(dashboard.view_count || '0'),
elements
};
} catch (error) {
console.error('Dashboard get error:', error);
throw error;
}
}
/**
* 대시보드 업데이트
*/
static async updateDashboard(
dashboardId: string,
data: UpdateDashboardRequest,
userId: string
): Promise<Dashboard | null> {
try {
const result = await PostgreSQLService.transaction(async (client) => {
// 권한 체크
const authCheckResult = await client.query(`
SELECT id FROM dashboards
WHERE id = $1 AND created_by = $2 AND deleted_at IS NULL
`, [dashboardId, userId]);
if (authCheckResult.rows.length === 0) {
throw new Error('대시보드를 찾을 수 없거나 수정 권한이 없습니다.');
}
const now = new Date();
// 1. 대시보드 메인 정보 업데이트
const updateFields: string[] = [];
const updateParams: any[] = [];
let paramIndex = 1;
if (data.title !== undefined) {
updateFields.push(`title = $${paramIndex}`);
updateParams.push(data.title);
paramIndex++;
}
if (data.description !== undefined) {
updateFields.push(`description = $${paramIndex}`);
updateParams.push(data.description);
paramIndex++;
}
if (data.isPublic !== undefined) {
updateFields.push(`is_public = $${paramIndex}`);
updateParams.push(data.isPublic);
paramIndex++;
}
if (data.tags !== undefined) {
updateFields.push(`tags = $${paramIndex}`);
updateParams.push(JSON.stringify(data.tags));
paramIndex++;
}
if (data.category !== undefined) {
updateFields.push(`category = $${paramIndex}`);
updateParams.push(data.category);
paramIndex++;
}
updateFields.push(`updated_at = $${paramIndex}`);
updateParams.push(now);
paramIndex++;
updateParams.push(dashboardId);
if (updateFields.length > 1) { // updated_at 외에 다른 필드가 있는 경우
const updateQuery = `
UPDATE dashboards
SET ${updateFields.join(', ')}
WHERE id = $${paramIndex}
`;
await client.query(updateQuery, updateParams);
}
// 2. 요소 업데이트 (있는 경우)
if (data.elements) {
// 기존 요소들 삭제
await client.query(`
DELETE FROM dashboard_elements WHERE dashboard_id = $1
`, [dashboardId]);
// 새 요소들 추가
for (let i = 0; i < data.elements.length; i++) {
const element = data.elements[i];
const elementId = uuidv4();
await client.query(`
INSERT INTO dashboard_elements (
id, dashboard_id, element_type, element_subtype,
position_x, position_y, width, height,
title, content, data_source_config, chart_config,
display_order, created_at, updated_at
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
`, [
elementId,
dashboardId,
element.type,
element.subtype,
element.position.x,
element.position.y,
element.size.width,
element.size.height,
element.title,
element.content || null,
JSON.stringify(element.dataSource || {}),
JSON.stringify(element.chartConfig || {}),
i,
now,
now
]);
}
}
return dashboardId;
});
// 업데이트된 대시보드 반환
return await this.getDashboardById(dashboardId, userId);
} catch (error) {
console.error('Dashboard update error:', error);
throw error;
}
}
/**
* 대시보드 삭제 (소프트 삭제)
*/
static async deleteDashboard(dashboardId: string, userId: string): Promise<boolean> {
try {
const now = new Date();
const result = await PostgreSQLService.query(`
UPDATE dashboards
SET deleted_at = $1, updated_at = $2
WHERE id = $3 AND created_by = $4 AND deleted_at IS NULL
`, [now, now, dashboardId, userId]);
return (result.rowCount || 0) > 0;
} catch (error) {
console.error('Dashboard delete error:', error);
throw error;
}
}
/**
* 조회수 증가
*/
static async incrementViewCount(dashboardId: string): Promise<void> {
try {
await PostgreSQLService.query(`
UPDATE dashboards
SET view_count = view_count + 1
WHERE id = $1 AND deleted_at IS NULL
`, [dashboardId]);
} catch (error) {
console.error('View count increment error:', error);
// 조회수 증가 실패는 치명적이지 않으므로 에러를 던지지 않음
}
}
/**
* 사용자 권한 체크
*/
static async checkUserPermission(
dashboardId: string,
userId: string,
requiredPermission: 'view' | 'edit' | 'admin' = 'view'
): Promise<boolean> {
try {
const result = await PostgreSQLService.query(`
SELECT
CASE
WHEN d.created_by = $2 THEN 'admin'
WHEN d.is_public = true THEN 'view'
ELSE 'none'
END as permission
FROM dashboards d
WHERE d.id = $1 AND d.deleted_at IS NULL
`, [dashboardId, userId]);
if (result.rows.length === 0) {
return false;
}
const userPermission = result.rows[0].permission;
// 권한 레벨 체크
const permissionLevels = { 'view': 1, 'edit': 2, 'admin': 3 };
const userLevel = permissionLevels[userPermission as keyof typeof permissionLevels] || 0;
const requiredLevel = permissionLevels[requiredPermission];
return userLevel >= requiredLevel;
} catch (error) {
console.error('Permission check error:', error);
return false;
}
}
}

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 : "알 수 없는 오류",
};
}
}

813
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) {

4
backend-node/src/services/tableManagementService.ts
View File

@ -1498,7 +1498,7 @@ export class TableManagementService {
// 전체 개수 조회
const countQuery = `SELECT COUNT(*) as count FROM ${safeTableName} ${whereClause}`;
const countResult = await query<any>(countQuery, ...searchValues);
const countResult = await query<any>(countQuery, searchValues);
const total = parseInt(countResult[0].count);
// 데이터 조회
@ -1509,7 +1509,7 @@ export class TableManagementService {
LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
`;
let data = await query<any>(dataQuery, ...searchValues, size, offset);
let data = await query<any>(dataQuery, [...searchValues, size, offset]);
// 🎯 파일 컬럼이 있으면 파일 정보 보강
if (fileColumns.length > 0) {

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);
});
});

90
backend-node/src/types/dashboard.ts Normal file
View File

@ -0,0 +1,90 @@
/**
* 대시보드 관련 타입 정의
*/
export interface DashboardElement {
id: string;
type: 'chart' | 'widget';
subtype: 'bar' | 'pie' | 'line' | 'exchange' | 'weather';
position: {
x: number;
y: number;
};
size: {
width: number;
height: number;
};
title: string;
content?: string;
dataSource?: {
type: 'api' | 'database' | 'static';
endpoint?: string;
query?: string;
refreshInterval?: number;
filters?: any[];
lastExecuted?: string;
};
chartConfig?: {
xAxis?: string;
yAxis?: string;
groupBy?: string;
aggregation?: 'sum' | 'avg' | 'count' | 'max' | 'min';
colors?: string[];
title?: string;
showLegend?: boolean;
};
}
export interface Dashboard {
id: string;
title: string;
description?: string;
thumbnailUrl?: string;
isPublic: boolean;
createdBy: string;
createdAt: string;
updatedAt: string;
deletedAt?: string;
tags?: string[];
category?: string;
viewCount: number;
elements: DashboardElement[];
}
export interface CreateDashboardRequest {
title: string;
description?: string;
isPublic?: boolean;
elements: DashboardElement[];
tags?: string[];
category?: string;
}
export interface UpdateDashboardRequest {
title?: string;
description?: string;
isPublic?: boolean;
elements?: DashboardElement[];
tags?: string[];
category?: string;
}
export interface DashboardListQuery {
page?: number;
limit?: number;
search?: string;
category?: string;
isPublic?: boolean;
createdBy?: string;
}
export interface DashboardShare {
id: string;
dashboardId: string;
sharedWithUser?: string;
sharedWithRole?: string;
permissionLevel: 'view' | 'edit' | 'admin';
createdBy: string;
createdAt: string;
expiresAt?: string;
}

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();

3
docker/dev/backend.Dockerfile
View File

@ -13,9 +13,6 @@ COPY package*.json ./
RUN npm ci --prefer-offline --no-audit
# 소스 코드는 볼륨 마운트로 처리
# Prisma 클라이언트 생성용 스키마만 복사
COPY prisma ./prisma
RUN npx prisma generate
# 포트 노출
EXPOSE 8080

10
docker/prod/backend.Dockerfile
View File

@ -9,14 +9,10 @@ RUN apt-get update \
&& apt-get install -y --no-install-recommends openssl ca-certificates curl \
&& rm -rf /var/lib/apt/lists/*
# Dependencies stage (install deps and generate Prisma client)
# Dependencies stage (install production dependencies)
FROM base AS deps
COPY package*.json ./
RUN npm ci --omit=dev --prefer-offline --no-audit && npm cache clean --force
# Copy prisma schema and generate client (glibc target will be detected)
COPY prisma ./prisma
ENV PRISMA_SKIP_POSTINSTALL_GENERATE=true
RUN npx prisma generate
# Build stage (compile TypeScript)
FROM node:20-bookworm-slim AS build
@ -25,8 +21,6 @@ COPY package*.json ./
RUN npm ci --prefer-offline --no-audit && npm cache clean --force
COPY tsconfig.json ./
COPY src ./src
COPY prisma ./prisma
RUN npx prisma generate
RUN npm run build
# Runtime image - base 이미지 재사용으로 중복 설치 제거
@ -36,7 +30,7 @@ ENV NODE_ENV=production
# Create non-root user
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
# Copy node_modules with generated Prisma client
# Copy production node_modules
COPY --from=deps /app/node_modules ./node_modules
# Copy built files
COPY --from=build /app/dist ./dist

18
frontend/app/(main)/admin/dashboard/page.tsx Normal file
View File

@ -0,0 +1,18 @@
'use client';
import React from 'react';
import DashboardDesigner from '@/components/admin/dashboard/DashboardDesigner';
/**
* 대시보드 관리 페이지
* - 드래그 앤 드롭으로 대시보드 레이아웃 설계
* - 차트 및 위젯 배치 관리
* - 독립적인 컴포넌트로 구성되어 다른 시스템에 영향 없음
*/
export default function DashboardPage() {
return (
<div className="h-full">
<DashboardDesigner />
</div>
);
}

286
frontend/app/(main)/dashboard/[dashboardId]/page.tsx Normal file
View File

@ -0,0 +1,286 @@
'use client';
import React, { useState, useEffect } from 'react';
import { DashboardViewer } from '@/components/dashboard/DashboardViewer';
import { DashboardElement } from '@/components/admin/dashboard/types';
interface DashboardViewPageProps {
params: {
dashboardId: string;
};
}
/**
* 대시보드 뷰어 페이지
* - 저장된 대시보드를 읽기 전용으로 표시
* - 실시간 데이터 업데이트
* - 전체화면 모드 지원
*/
export default function DashboardViewPage({ params }: DashboardViewPageProps) {
const [dashboard, setDashboard] = useState<{
id: string;
title: string;
description?: string;
elements: DashboardElement[];
createdAt: string;
updatedAt: string;
} | null>(null);
const [isLoading, setIsLoading] = useState(true);
const [error, setError] = useState<string | null>(null);
// 대시보드 데이터 로딩
useEffect(() => {
loadDashboard();
}, [params.dashboardId]);
const loadDashboard = async () => {
setIsLoading(true);
setError(null);
try {
// 실제 API 호출 시도
const { dashboardApi } = await import('@/lib/api/dashboard');
try {
const dashboardData = await dashboardApi.getDashboard(params.dashboardId);
setDashboard(dashboardData);
} catch (apiError) {
console.warn('API 호출 실패, 로컬 스토리지 확인:', apiError);
// API 실패 시 로컬 스토리지에서 찾기
const savedDashboards = JSON.parse(localStorage.getItem('savedDashboards') || '[]');
const savedDashboard = savedDashboards.find((d: any) => d.id === params.dashboardId);
if (savedDashboard) {
setDashboard(savedDashboard);
} else {
// 로컬에도 없으면 샘플 데이터 사용
const sampleDashboard = generateSampleDashboard(params.dashboardId);
setDashboard(sampleDashboard);
}
}
} catch (err) {
setError('대시보드를 불러오는 중 오류가 발생했습니다.');
console.error('Dashboard loading error:', err);
} finally {
setIsLoading(false);
}
};
// 로딩 상태
if (isLoading) {
return (
<div className="h-screen flex items-center justify-center bg-gray-50">
<div className="text-center">
<div className="w-12 h-12 border-4 border-blue-500 border-t-transparent rounded-full animate-spin mx-auto mb-4" />
<div className="text-lg font-medium text-gray-700">대시보드 로딩 중...</div>
<div className="text-sm text-gray-500 mt-1">잠시만 기다려주세요</div>
</div>
</div>
);
}
// 에러 상태
if (error || !dashboard) {
return (
<div className="h-screen flex items-center justify-center bg-gray-50">
<div className="text-center">
<div className="text-6xl mb-4">😞</div>
<div className="text-xl font-medium text-gray-700 mb-2">
{error || '대시보드를 찾을 수 없습니다'}
</div>
<div className="text-sm text-gray-500 mb-4">
대시보드 ID: {params.dashboardId}
</div>
<button
onClick={loadDashboard}
className="px-4 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600"
>
다시 시도
</button>
</div>
</div>
);
}
return (
<div className="h-screen bg-gray-50">
{/* 대시보드 헤더 */}
<div className="bg-white border-b border-gray-200 px-6 py-4">
<div className="flex justify-between items-center">
<div>
<h1 className="text-2xl font-bold text-gray-800">{dashboard.title}</h1>
{dashboard.description && (
<p className="text-sm text-gray-600 mt-1">{dashboard.description}</p>
)}
</div>
<div className="flex items-center gap-3">
{/* 새로고침 버튼 */}
<button
onClick={loadDashboard}
className="px-3 py-2 text-gray-600 hover:text-gray-800 border border-gray-300 rounded-lg hover:bg-gray-50"
title="새로고침"
>
🔄
</button>
{/* 전체화면 버튼 */}
<button
onClick={() => {
if (document.fullscreenElement) {
document.exitFullscreen();
} else {
document.documentElement.requestFullscreen();
}
}}
className="px-3 py-2 text-gray-600 hover:text-gray-800 border border-gray-300 rounded-lg hover:bg-gray-50"
title="전체화면"
>
⛶
</button>
{/* 편집 버튼 */}
<button
onClick={() => {
window.open(`/admin/dashboard?load=${params.dashboardId}`, '_blank');
}}
className="px-4 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600"
>
편집
</button>
</div>
</div>
{/* 메타 정보 */}
<div className="flex items-center gap-4 mt-2 text-xs text-gray-500">
<span>생성: {new Date(dashboard.createdAt).toLocaleString()}</span>
<span>수정: {new Date(dashboard.updatedAt).toLocaleString()}</span>
<span>요소: {dashboard.elements.length}개</span>
</div>
</div>
{/* 대시보드 뷰어 */}
<div className="h-[calc(100vh-120px)]">
<DashboardViewer
elements={dashboard.elements}
dashboardId={dashboard.id}
/>
</div>
</div>
);
}
/**
* 샘플 대시보드 생성 함수
*/
function generateSampleDashboard(dashboardId: string) {
const dashboards: Record<string, any> = {
'sales-overview': {
id: 'sales-overview',
title: '📊 매출 현황 대시보드',
description: '월별 매출 추이 및 상품별 판매 현황을 한눈에 확인할 수 있습니다.',
elements: [
{
id: 'chart-1',
type: 'chart',
subtype: 'bar',
position: { x: 20, y: 20 },
size: { width: 400, height: 300 },
title: '📊 월별 매출 추이',
content: '월별 매출 데이터',
dataSource: {
type: 'database',
query: 'SELECT month, sales FROM monthly_sales',
refreshInterval: 30000
},
chartConfig: {
xAxis: 'month',
yAxis: 'sales',
title: '월별 매출 추이',
colors: ['#3B82F6', '#EF4444', '#10B981']
}
},
{
id: 'chart-2',
type: 'chart',
subtype: 'pie',
position: { x: 450, y: 20 },
size: { width: 350, height: 300 },
title: '🥧 상품별 판매 비율',
content: '상품별 판매 데이터',
dataSource: {
type: 'database',
query: 'SELECT product_name, total_sold FROM product_sales',
refreshInterval: 60000
},
chartConfig: {
xAxis: 'product_name',
yAxis: 'total_sold',
title: '상품별 판매 비율',
colors: ['#8B5CF6', '#EC4899', '#06B6D4', '#84CC16']
}
},
{
id: 'chart-3',
type: 'chart',
subtype: 'line',
position: { x: 20, y: 350 },
size: { width: 780, height: 250 },
title: '📈 사용자 가입 추이',
content: '사용자 가입 데이터',
dataSource: {
type: 'database',
query: 'SELECT week, new_users FROM user_growth',
refreshInterval: 300000
},
chartConfig: {
xAxis: 'week',
yAxis: 'new_users',
title: '주간 신규 사용자 가입 추이',
colors: ['#10B981']
}
}
],
createdAt: '2024-09-30T10:00:00Z',
updatedAt: '2024-09-30T14:30:00Z'
},
'user-analytics': {
id: 'user-analytics',
title: '👥 사용자 분석 대시보드',
description: '사용자 행동 패턴 및 가입 추이 분석',
elements: [
{
id: 'chart-4',
type: 'chart',
subtype: 'line',
position: { x: 20, y: 20 },
size: { width: 500, height: 300 },
title: '📈 일일 활성 사용자',
content: '사용자 활동 데이터',
dataSource: {
type: 'database',
query: 'SELECT date, active_users FROM daily_active_users',
refreshInterval: 60000
},
chartConfig: {
xAxis: 'date',
yAxis: 'active_users',
title: '일일 활성 사용자 추이'
}
}
],
createdAt: '2024-09-29T15:00:00Z',
updatedAt: '2024-09-30T09:15:00Z'
}
};
return dashboards[dashboardId] || {
id: dashboardId,
title: `대시보드 ${dashboardId}`,
description: '샘플 대시보드입니다.',
elements: [],
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString()
};
}

513
frontend/app/(main)/dashboard/page.tsx
View File

@ -1,270 +1,287 @@
"use client";
'use client';
import { useState } from "react";
import { Button } from "@/components/ui/button";
import { Card, CardContent } from "@/components/ui/card";
import {
Home,
FileText,
Users,
Settings,
Package,
BarChart3,
LogOut,
Menu,
X,
ChevronDown,
ChevronRight,
} from "lucide-react";
import { useAuth } from "@/hooks/useAuth";
import React, { useState, useEffect } from 'react';
import Link from 'next/link';
interface UserInfo {
userId: string;
userName: string;
deptName: string;
email: string;
}
interface MenuItem {
interface Dashboard {
id: string;
title: string;
icon: any;
children?: MenuItem[];
description?: string;
thumbnail?: string;
elementsCount: number;
createdAt: string;
updatedAt: string;
isPublic: boolean;
}
const menuItems: MenuItem[] = [
{
id: "dashboard",
title: "대시보드",
icon: Home,
},
{
id: "project",
title: "프로젝트 관리",
icon: FileText,
children: [
{ id: "project-list", title: "프로젝트 목록", icon: FileText },
{ id: "project-concept", title: "프로젝트 컨셉", icon: FileText },
{ id: "project-planning", title: "프로젝트 기획", icon: FileText },
],
},
{
id: "part",
title: "부품 관리",
icon: Package,
children: [
{ id: "part-list", title: "부품 목록", icon: Package },
{ id: "part-bom", title: "BOM 관리", icon: Package },
{ id: "part-inventory", title: "재고 관리", icon: Package },
],
},
{
id: "user",
title: "사용자 관리",
icon: Users,
children: [
{ id: "user-list", title: "사용자 목록", icon: Users },
{ id: "user-auth", title: "권한 관리", icon: Users },
],
},
{
id: "report",
title: "보고서",
icon: BarChart3,
children: [
{ id: "report-project", title: "프로젝트 보고서", icon: BarChart3 },
{ id: "report-cost", title: "비용 보고서", icon: BarChart3 },
],
},
{
id: "settings",
title: "시스템 설정",
icon: Settings,
children: [
{ id: "settings-system", title: "시스템 설정", icon: Settings },
{ id: "settings-common", title: "공통 코드", icon: Settings },
],
},
];
/**
* 대시보드 목록 페이지
* - 저장된 대시보드들의 목록 표시
* - 새 대시보드 생성 링크
* - 대시보드 미리보기 및 관리
*/
export default function DashboardListPage() {
const [dashboards, setDashboards] = useState<Dashboard[]>([]);
const [isLoading, setIsLoading] = useState(true);
const [searchTerm, setSearchTerm] = useState('');
export default function DashboardPage() {
const { user, logout } = useAuth();
const [sidebarOpen, setSidebarOpen] = useState(true);
const [expandedMenus, setExpandedMenus] = useState<Set<string>>(new Set(["dashboard"]));
const [selectedMenu, setSelectedMenu] = useState("dashboard");
const [currentContent, setCurrentContent] = useState<string>("dashboard");
// 대시보드 목록 로딩
useEffect(() => {
loadDashboards();
}, []);
const handleLogout = async () => {
await logout();
};
const toggleMenu = (menuId: string) => {
const newExpanded = new Set(expandedMenus);
if (newExpanded.has(menuId)) {
newExpanded.delete(menuId);
} else {
newExpanded.add(menuId);
}
setExpandedMenus(newExpanded);
};
const handleMenuClick = (menuId: string) => {
setSelectedMenu(menuId);
setCurrentContent(menuId);
};
const renderContent = () => {
switch (currentContent) {
case "dashboard":
return (
<div className="space-y-6">
<h1 className="text-3xl font-bold text-slate-900">대시보드</h1>
<div className="grid grid-cols-1 gap-6 md:grid-cols-2 lg:grid-cols-4">
<Card>
<CardContent className="p-6">
<div className="flex items-center">
<FileText className="h-8 w-8 text-blue-600" />
<div className="ml-4">
<p className="text-sm font-medium text-slate-600">전체 프로젝트</p>
<p className="text-2xl font-bold text-slate-900">24</p>
</div>
</div>
</CardContent>
</Card>
<Card>
<CardContent className="p-6">
<div className="flex items-center">
<Package className="h-8 w-8 text-green-600" />
<div className="ml-4">
<p className="text-sm font-medium text-slate-600">등록된 부품</p>
<p className="text-2xl font-bold text-slate-900">1,247</p>
</div>
</div>
</CardContent>
</Card>
<Card>
<CardContent className="p-6">
<div className="flex items-center">
<Users className="h-8 w-8 text-purple-600" />
<div className="ml-4">
<p className="text-sm font-medium text-slate-600">활성 사용자</p>
<p className="text-2xl font-bold text-slate-900">89</p>
</div>
</div>
</CardContent>
</Card>
<Card>
<CardContent className="p-6">
<div className="flex items-center">
<BarChart3 className="h-8 w-8 text-orange-600" />
<div className="ml-4">
<p className="text-sm font-medium text-slate-600">진행중인 작업</p>
<p className="text-2xl font-bold text-slate-900">12</p>
</div>
</div>
</CardContent>
</Card>
</div>
<Card>
<CardContent className="p-6">
<h2 className="mb-4 text-xl font-semibold">최근 활동</h2>
<div className="space-y-4">
<div className="flex items-center space-x-4">
<div className="h-2 w-2 rounded-full bg-blue-500"></div>
<span className="text-sm text-slate-600">새로운 프로젝트 '제품 A' 생성됨</span>
<span className="text-xs text-slate-400">2시간 전</span>
</div>
<div className="flex items-center space-x-4">
<div className="h-2 w-2 rounded-full bg-green-500"></div>
<span className="text-sm text-slate-600">부품 'PCB-001' 승인 완료</span>
<span className="text-xs text-slate-400">4시간 전</span>
</div>
<div className="flex items-center space-x-4">
<div className="h-2 w-2 rounded-full bg-orange-500"></div>
<span className="text-sm text-slate-600">사용자 '김개발' 권한 변경</span>
<span className="text-xs text-slate-400">1일 전</span>
</div>
</div>
</CardContent>
</Card>
</div>
);
default:
return (
<div className="space-y-6">
<h1 className="text-3xl font-bold text-slate-900">
{menuItems.find((item) => item.id === currentContent)?.title ||
menuItems.flatMap((item) => item.children || []).find((child) => child.id === currentContent)?.title ||
"페이지를 찾을 수 없습니다"}
</h1>
<Card>
<CardContent className="p-6">
<p className="text-slate-600">{currentContent} 페이지 컨텐츠가 여기에 표시됩니다.</p>
<p className="mt-2 text-sm text-slate-400">각 메뉴에 맞는 컴포넌트를 개발하여 연결할 수 있습니다.</p>
</CardContent>
</Card>
</div>
);
const loadDashboards = async () => {
setIsLoading(true);
try {
// 실제 API 호출 시도
const { dashboardApi } = await import('@/lib/api/dashboard');
try {
const result = await dashboardApi.getDashboards({ page: 1, limit: 50 });
// API에서 가져온 대시보드들을 Dashboard 형식으로 변환
const apiDashboards: Dashboard[] = result.dashboards.map((dashboard: any) => ({
id: dashboard.id,
title: dashboard.title,
description: dashboard.description,
elementsCount: dashboard.elementsCount || dashboard.elements?.length || 0,
createdAt: dashboard.createdAt,
updatedAt: dashboard.updatedAt,
isPublic: dashboard.isPublic,
creatorName: dashboard.creatorName
}));
setDashboards(apiDashboards);
} catch (apiError) {
console.warn('API 호출 실패, 로컬 스토리지 및 샘플 데이터 사용:', apiError);
// API 실패 시 로컬 스토리지 + 샘플 데이터 사용
const savedDashboards = JSON.parse(localStorage.getItem('savedDashboards') || '[]');
// 샘플 대시보드들
const sampleDashboards: Dashboard[] = [
{
id: 'sales-overview',
title: '📊 매출 현황 대시보드',
description: '월별 매출 추이 및 상품별 판매 현황을 한눈에 확인할 수 있습니다.',
elementsCount: 3,
createdAt: '2024-09-30T10:00:00Z',
updatedAt: '2024-09-30T14:30:00Z',
isPublic: true
},
{
id: 'user-analytics',
title: '👥 사용자 분석 대시보드',
description: '사용자 행동 패턴 및 가입 추이 분석',
elementsCount: 1,
createdAt: '2024-09-29T15:00:00Z',
updatedAt: '2024-09-30T09:15:00Z',
isPublic: false
},
{
id: 'inventory-status',
title: '📦 재고 현황 대시보드',
description: '실시간 재고 현황 및 입출고 내역',
elementsCount: 4,
createdAt: '2024-09-28T11:30:00Z',
updatedAt: '2024-09-29T16:45:00Z',
isPublic: true
}
];
// 저장된 대시보드를 Dashboard 형식으로 변환
const userDashboards: Dashboard[] = savedDashboards.map((dashboard: any) => ({
id: dashboard.id,
title: dashboard.title,
description: dashboard.description,
elementsCount: dashboard.elements?.length || 0,
createdAt: dashboard.createdAt,
updatedAt: dashboard.updatedAt,
isPublic: false // 사용자가 만든 대시보드는 기본적으로 비공개
}));
// 사용자 대시보드를 맨 앞에 배치
setDashboards([...userDashboards, ...sampleDashboards]);
}
} catch (error) {
console.error('Dashboard loading error:', error);
} finally {
setIsLoading(false);
}
};
const renderMenuItem = (item: MenuItem, level: number = 0) => {
const isExpanded = expandedMenus.has(item.id);
const isSelected = selectedMenu === item.id;
const hasChildren = item.children && item.children.length > 0;
return (
<div key={item.id}>
<div
className={`flex cursor-pointer items-center rounded-md px-4 py-2 text-sm transition-colors ${
isSelected ? "bg-blue-600 text-white" : "text-slate-700 hover:bg-slate-100"
} ${level > 0 ? "ml-6" : ""}`}
onClick={() => {
if (hasChildren) {
toggleMenu(item.id);
} else {
handleMenuClick(item.id);
}
}}
>
<item.icon className="mr-3 h-4 w-4" />
<span className="flex-1">{item.title}</span>
{hasChildren && (isExpanded ? <ChevronDown className="h-4 w-4" /> : <ChevronRight className="h-4 w-4" />)}
</div>
{hasChildren && isExpanded && (
<div className="mt-1">{item.children?.map((child) => renderMenuItem(child, level + 1))}</div>
)}
</div>
);
};
// 검색 필터링
const filteredDashboards = dashboards.filter(dashboard =>
dashboard.title.toLowerCase().includes(searchTerm.toLowerCase()) ||
dashboard.description?.toLowerCase().includes(searchTerm.toLowerCase())
);
return (
<div className="min-h-screen bg-slate-50">
<div className="min-h-screen bg-gray-50">
{/* 헤더 */}
<header className="border-b border-slate-200 bg-white shadow-sm">
<div className="px-6 py-4">
<div className="flex items-center justify-between">
<div className="flex items-center space-x-4">
<Button variant="ghost" size="sm" onClick={() => setSidebarOpen(!sidebarOpen)}>
<Menu className="h-5 w-5" />
</Button>
<h1 className="text-xl font-semibold text-slate-900">PLM 시스템</h1>
<div className="bg-white border-b border-gray-200">
<div className="max-w-7xl mx-auto px-6 py-6">
<div className="flex justify-between items-center">
<div>
<h1 className="text-3xl font-bold text-gray-900">📊 대시보드</h1>
<p className="text-gray-600 mt-1">데이터를 시각화하고 인사이트를 얻어보세요</p>
</div>
<Link
href="/admin/dashboard"
className="px-6 py-3 bg-blue-500 text-white rounded-lg hover:bg-blue-600 font-medium"
>
➕ 새 대시보드 만들기
</Link>
</div>
{/* 검색 바 */}
<div className="mt-6">
<div className="relative max-w-md">
<input
type="text"
placeholder="대시보드 검색..."
value={searchTerm}
onChange={(e) => setSearchTerm(e.target.value)}
className="w-full pl-10 pr-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
/>
<div className="absolute left-3 top-2.5 text-gray-400">
🔍
</div>
</div>
</div>
</div>
</header>
</div>
<div className="flex">
{/* 사이드바 */}
<aside
className={`${sidebarOpen ? "w-64" : "w-0"} overflow-hidden border-r border-slate-200 bg-white transition-all duration-300`}
>
<nav className="space-y-2 p-4">{menuItems.map((item) => renderMenuItem(item))}</nav>
</aside>
{/* 메인 컨텐츠 */}
<main className="flex-1 p-6">{renderContent()}</main>
{/* 메인 콘텐츠 */}
<div className="max-w-7xl mx-auto px-6 py-8">
{isLoading ? (
// 로딩 상태
<div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
{[1, 2, 3, 4, 5, 6].map((i) => (
<div key={i} className="bg-white rounded-lg shadow-sm border border-gray-200 p-6">
<div className="animate-pulse">
<div className="h-4 bg-gray-200 rounded w-3/4 mb-3"></div>
<div className="h-3 bg-gray-200 rounded w-full mb-2"></div>
<div className="h-3 bg-gray-200 rounded w-2/3 mb-4"></div>
<div className="h-32 bg-gray-200 rounded mb-4"></div>
<div className="flex justify-between">
<div className="h-3 bg-gray-200 rounded w-1/4"></div>
<div className="h-3 bg-gray-200 rounded w-1/4"></div>
</div>
</div>
</div>
))}
</div>
) : filteredDashboards.length === 0 ? (
// 빈 상태
<div className="text-center py-12">
<div className="text-6xl mb-4">📊</div>
<h3 className="text-xl font-medium text-gray-700 mb-2">
{searchTerm ? '검색 결과가 없습니다' : '아직 대시보드가 없습니다'}
</h3>
<p className="text-gray-500 mb-6">
{searchTerm
? '다른 검색어로 시도해보세요'
: '첫 번째 대시보드를 만들어보세요'}
</p>
{!searchTerm && (
<Link
href="/admin/dashboard"
className="inline-flex items-center px-6 py-3 bg-blue-500 text-white rounded-lg hover:bg-blue-600 font-medium"
>
➕ 대시보드 만들기
</Link>
)}
</div>
) : (
// 대시보드 그리드
<div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
{filteredDashboards.map((dashboard) => (
<DashboardCard key={dashboard.id} dashboard={dashboard} />
))}
</div>
)}
</div>
</div>
);
}
interface DashboardCardProps {
dashboard: Dashboard;
}
/**
* 개별 대시보드 카드 컴포넌트
*/
function DashboardCard({ dashboard }: DashboardCardProps) {
return (
<div className="bg-white rounded-lg shadow-sm border border-gray-200 hover:shadow-md transition-shadow">
{/* 썸네일 영역 */}
<div className="h-48 bg-gradient-to-br from-blue-50 to-indigo-100 rounded-t-lg flex items-center justify-center">
<div className="text-center">
<div className="text-4xl mb-2">📊</div>
<div className="text-sm text-gray-600">{dashboard.elementsCount}개 요소</div>
</div>
</div>
{/* 카드 내용 */}
<div className="p-6">
<div className="flex justify-between items-start mb-3">
<h3 className="text-lg font-semibold text-gray-900 line-clamp-1">
{dashboard.title}
</h3>
{dashboard.isPublic ? (
<span className="text-xs bg-green-100 text-green-800 px-2 py-1 rounded-full">
공개
</span>
) : (
<span className="text-xs bg-gray-100 text-gray-800 px-2 py-1 rounded-full">
비공개
</span>
)}
</div>
{dashboard.description && (
<p className="text-gray-600 text-sm mb-4 line-clamp-2">
{dashboard.description}
</p>
)}
{/* 메타 정보 */}
<div className="text-xs text-gray-500 mb-4">
<div>생성: {new Date(dashboard.createdAt).toLocaleDateString()}</div>
<div>수정: {new Date(dashboard.updatedAt).toLocaleDateString()}</div>
</div>
{/* 액션 버튼들 */}
<div className="flex gap-2">
<Link
href={`/dashboard/${dashboard.id}`}
className="flex-1 px-4 py-2 bg-blue-500 text-white text-center rounded-lg hover:bg-blue-600 text-sm font-medium"
>
보기
</Link>
<Link
href={`/admin/dashboard?load=${dashboard.id}`}
className="px-4 py-2 border border-gray-300 text-gray-700 rounded-lg hover:bg-gray-50 text-sm"
>
편집
</Link>
<button
onClick={() => {
// 복사 기능 구현
console.log('Dashboard copy:', dashboard.id);
}}
className="px-4 py-2 border border-gray-300 text-gray-700 rounded-lg hover:bg-gray-50 text-sm"
title="복사"
>
📋
</button>
</div>
</div>
</div>
);
}

398
frontend/components/admin/dashboard/CanvasElement.tsx Normal file
View File

@ -0,0 +1,398 @@
'use client';
import React, { useState, useCallback, useRef, useEffect } from 'react';
import { DashboardElement, QueryResult } from './types';
import { ChartRenderer } from './charts/ChartRenderer';
interface CanvasElementProps {
element: DashboardElement;
isSelected: boolean;
onUpdate: (id: string, updates: Partial<DashboardElement>) => void;
onRemove: (id: string) => void;
onSelect: (id: string | null) => void;
onConfigure?: (element: DashboardElement) => void;
}
/**
* 캔버스에 배치된 개별 요소 컴포넌트
* - 드래그로 이동 가능
* - 크기 조절 핸들
* - 삭제 버튼
*/
export function CanvasElement({ element, isSelected, onUpdate, onRemove, onSelect, onConfigure }: CanvasElementProps) {
const [isDragging, setIsDragging] = useState(false);
const [isResizing, setIsResizing] = useState(false);
const [dragStart, setDragStart] = useState({ x: 0, y: 0, elementX: 0, elementY: 0 });
const [resizeStart, setResizeStart] = useState({
x: 0, y: 0, width: 0, height: 0, elementX: 0, elementY: 0, handle: ''
});
const [chartData, setChartData] = useState<QueryResult | null>(null);
const [isLoadingData, setIsLoadingData] = useState(false);
const elementRef = useRef<HTMLDivElement>(null);
// 요소 선택 처리
const handleMouseDown = useCallback((e: React.MouseEvent) => {
// 닫기 버튼이나 리사이즈 핸들 클릭 시 무시
if ((e.target as HTMLElement).closest('.element-close, .resize-handle')) {
return;
}
onSelect(element.id);
setIsDragging(true);
setDragStart({
x: e.clientX,
y: e.clientY,
elementX: element.position.x,
elementY: element.position.y
});
e.preventDefault();
}, [element.id, element.position.x, element.position.y, onSelect]);
// 리사이즈 핸들 마우스다운
const handleResizeMouseDown = useCallback((e: React.MouseEvent, handle: string) => {
e.stopPropagation();
setIsResizing(true);
setResizeStart({
x: e.clientX,
y: e.clientY,
width: element.size.width,
height: element.size.height,
elementX: element.position.x,
elementY: element.position.y,
handle
});
}, [element.size.width, element.size.height, element.position.x, element.position.y]);
// 마우스 이동 처리
const handleMouseMove = useCallback((e: MouseEvent) => {
if (isDragging) {
const deltaX = e.clientX - dragStart.x;
const deltaY = e.clientY - dragStart.y;
onUpdate(element.id, {
position: {
x: Math.max(0, dragStart.elementX + deltaX),
y: Math.max(0, dragStart.elementY + deltaY)
}
});
} else if (isResizing) {
const deltaX = e.clientX - resizeStart.x;
const deltaY = e.clientY - resizeStart.y;
let newWidth = resizeStart.width;
let newHeight = resizeStart.height;
let newX = resizeStart.elementX;
let newY = resizeStart.elementY;
switch (resizeStart.handle) {
case 'se': // 오른쪽 아래
newWidth = Math.max(150, resizeStart.width + deltaX);
newHeight = Math.max(150, resizeStart.height + deltaY);
break;
case 'sw': // 왼쪽 아래
newWidth = Math.max(150, resizeStart.width - deltaX);
newHeight = Math.max(150, resizeStart.height + deltaY);
newX = resizeStart.elementX + deltaX;
break;
case 'ne': // 오른쪽 위
newWidth = Math.max(150, resizeStart.width + deltaX);
newHeight = Math.max(150, resizeStart.height - deltaY);
newY = resizeStart.elementY + deltaY;
break;
case 'nw': // 왼쪽 위
newWidth = Math.max(150, resizeStart.width - deltaX);
newHeight = Math.max(150, resizeStart.height - deltaY);
newX = resizeStart.elementX + deltaX;
newY = resizeStart.elementY + deltaY;
break;
}
onUpdate(element.id, {
position: { x: Math.max(0, newX), y: Math.max(0, newY) },
size: { width: newWidth, height: newHeight }
});
}
}, [isDragging, isResizing, dragStart, resizeStart, element.id, onUpdate]);
// 마우스 업 처리
const handleMouseUp = useCallback(() => {
setIsDragging(false);
setIsResizing(false);
}, []);
// 전역 마우스 이벤트 등록
React.useEffect(() => {
if (isDragging || isResizing) {
document.addEventListener('mousemove', handleMouseMove);
document.addEventListener('mouseup', handleMouseUp);
return () => {
document.removeEventListener('mousemove', handleMouseMove);
document.removeEventListener('mouseup', handleMouseUp);
};
}
}, [isDragging, isResizing, handleMouseMove, handleMouseUp]);
// 데이터 로딩
const loadChartData = useCallback(async () => {
if (!element.dataSource?.query || element.type !== 'chart') {
return;
}
setIsLoadingData(true);
try {
// console.log('🔄 쿼리 실행 시작:', element.dataSource.query);
// 실제 API 호출
const { dashboardApi } = await import('@/lib/api/dashboard');
const result = await dashboardApi.executeQuery(element.dataSource.query);
// console.log('✅ 쿼리 실행 결과:', result);
setChartData({
columns: result.columns || [],
rows: result.rows || [],
totalRows: result.rowCount || 0,
executionTime: 0
});
} catch (error) {
// console.error('❌ 데이터 로딩 오류:', error);
setChartData(null);
} finally {
setIsLoadingData(false);
}
}, [element.dataSource?.query, element.type, element.subtype]);
// 컴포넌트 마운트 시 및 쿼리 변경 시 데이터 로딩
useEffect(() => {
loadChartData();
}, [loadChartData]);
// 자동 새로고침 설정
useEffect(() => {
if (!element.dataSource?.refreshInterval || element.dataSource.refreshInterval === 0) {
return;
}
const interval = setInterval(loadChartData, element.dataSource.refreshInterval);
return () => clearInterval(interval);
}, [element.dataSource?.refreshInterval, loadChartData]);
// 요소 삭제
const handleRemove = useCallback(() => {
onRemove(element.id);
}, [element.id, onRemove]);
// 스타일 클래스 생성
const getContentClass = () => {
if (element.type === 'chart') {
switch (element.subtype) {
case 'bar': return 'bg-gradient-to-br from-indigo-400 to-purple-600';
case 'pie': return 'bg-gradient-to-br from-pink-400 to-red-500';
case 'line': return 'bg-gradient-to-br from-blue-400 to-cyan-400';
default: return 'bg-gray-200';
}
} else if (element.type === 'widget') {
switch (element.subtype) {
case 'exchange': return 'bg-gradient-to-br from-pink-400 to-yellow-400';
case 'weather': return 'bg-gradient-to-br from-cyan-400 to-indigo-800';
default: return 'bg-gray-200';
}
}
return 'bg-gray-200';
};
return (
<div
ref={elementRef}
className={`
absolute bg-white border-2 rounded-lg shadow-lg
min-w-[150px] min-h-[150px] cursor-move
${isSelected ? 'border-green-500 shadow-green-200' : 'border-gray-600'}
`}
style={{
left: element.position.x,
top: element.position.y,
width: element.size.width,
height: element.size.height
}}
onMouseDown={handleMouseDown}
>
{/* 헤더 */}
<div className="bg-gray-50 p-3 border-b border-gray-200 flex justify-between items-center cursor-move">
<span className="font-bold text-sm text-gray-800">{element.title}</span>
<div className="flex gap-1">
{/* 설정 버튼 */}
{onConfigure && (
<button
className="
w-6 h-6 flex items-center justify-center
text-gray-400 hover:bg-blue-500 hover:text-white
rounded transition-colors duration-200
"
onClick={() => onConfigure(element)}
title="설정"
>
⚙️
</button>
)}
{/* 삭제 버튼 */}
<button
className="
element-close w-6 h-6 flex items-center justify-center
text-gray-400 hover:bg-red-500 hover:text-white
rounded transition-colors duration-200
"
onClick={handleRemove}
title="삭제"
>
×
</button>
</div>
</div>
{/* 내용 */}
<div className="h-[calc(100%-45px)] relative">
{element.type === 'chart' ? (
// 차트 렌더링
<div className="w-full h-full bg-white">
{isLoadingData ? (
<div className="w-full h-full flex items-center justify-center text-gray-500">
<div className="text-center">
<div className="w-6 h-6 border-2 border-blue-500 border-t-transparent rounded-full animate-spin mx-auto mb-2" />
<div className="text-sm">데이터 로딩 중...</div>
</div>
</div>
) : (
<ChartRenderer
element={element}
data={chartData}
width={element.size.width}
height={element.size.height - 45}
/>
)}
</div>
) : (
// 위젯 렌더링 (기존 방식)
<div className={`
w-full h-full p-5 flex items-center justify-center
text-sm text-white font-medium text-center
${getContentClass()}
`}>
<div>
<div className="text-4xl mb-2">
{element.type === 'widget' && element.subtype === 'exchange' && '💱'}
{element.type === 'widget' && element.subtype === 'weather' && '☁️'}
</div>
<div className="whitespace-pre-line">{element.content}</div>
</div>
</div>
)}
</div>
{/* 리사이즈 핸들 (선택된 요소에만 표시) */}
{isSelected && (
<>
<ResizeHandle position="nw" onMouseDown={handleResizeMouseDown} />
<ResizeHandle position="ne" onMouseDown={handleResizeMouseDown} />
<ResizeHandle position="sw" onMouseDown={handleResizeMouseDown} />
<ResizeHandle position="se" onMouseDown={handleResizeMouseDown} />
</>
)}
</div>
);
}
interface ResizeHandleProps {
position: 'nw' | 'ne' | 'sw' | 'se';
onMouseDown: (e: React.MouseEvent, handle: string) => void;
}
/**
* 크기 조절 핸들 컴포넌트
*/
function ResizeHandle({ position, onMouseDown }: ResizeHandleProps) {
const getPositionClass = () => {
switch (position) {
case 'nw': return 'top-[-5px] left-[-5px] cursor-nw-resize';
case 'ne': return 'top-[-5px] right-[-5px] cursor-ne-resize';
case 'sw': return 'bottom-[-5px] left-[-5px] cursor-sw-resize';
case 'se': return 'bottom-[-5px] right-[-5px] cursor-se-resize';
}
};
return (
<div
className={`
resize-handle absolute w-3 h-3 bg-green-500 border border-white
${getPositionClass()}
`}
onMouseDown={(e) => onMouseDown(e, position)}
/>
);
}
/**
* 샘플 데이터 생성 함수 (실제 API 호출 대신 사용)
*/
function generateSampleData(query: string, chartType: string): QueryResult {
// 쿼리에서 키워드 추출하여 적절한 샘플 데이터 생성
const isMonthly = query.toLowerCase().includes('month');
const isSales = query.toLowerCase().includes('sales') || query.toLowerCase().includes('매출');
const isUsers = query.toLowerCase().includes('users') || query.toLowerCase().includes('사용자');
const isProducts = query.toLowerCase().includes('product') || query.toLowerCase().includes('상품');
let columns: string[];
let rows: Record<string, any>[];
if (isMonthly && isSales) {
// 월별 매출 데이터
columns = ['month', 'sales', 'order_count'];
rows = [
{ month: '2024-01', sales: 1200000, order_count: 45 },
{ month: '2024-02', sales: 1350000, order_count: 52 },
{ month: '2024-03', sales: 1180000, order_count: 41 },
{ month: '2024-04', sales: 1420000, order_count: 58 },
{ month: '2024-05', sales: 1680000, order_count: 67 },
{ month: '2024-06', sales: 1540000, order_count: 61 },
];
} else if (isUsers) {
// 사용자 가입 추이
columns = ['week', 'new_users'];
rows = [
{ week: '2024-W10', new_users: 23 },
{ week: '2024-W11', new_users: 31 },
{ week: '2024-W12', new_users: 28 },
{ week: '2024-W13', new_users: 35 },
{ week: '2024-W14', new_users: 42 },
{ week: '2024-W15', new_users: 38 },
];
} else if (isProducts) {
// 상품별 판매량
columns = ['product_name', 'total_sold', 'revenue'];
rows = [
{ product_name: '스마트폰', total_sold: 156, revenue: 234000000 },
{ product_name: '노트북', total_sold: 89, revenue: 178000000 },
{ product_name: '태블릿', total_sold: 134, revenue: 67000000 },
{ product_name: '이어폰', total_sold: 267, revenue: 26700000 },
{ product_name: '스마트워치', total_sold: 98, revenue: 49000000 },
];
} else {
// 기본 샘플 데이터
columns = ['category', 'value', 'count'];
rows = [
{ category: 'A', value: 100, count: 10 },
{ category: 'B', value: 150, count: 15 },
{ category: 'C', value: 120, count: 12 },
{ category: 'D', value: 180, count: 18 },
{ category: 'E', value: 90, count: 9 },
];
}
return {
columns,
rows,
totalRows: rows.length,
executionTime: Math.floor(Math.random() * 100) + 50, // 50-150ms
};
}

262
frontend/components/admin/dashboard/ChartConfigPanel.tsx Normal file
View File

@ -0,0 +1,262 @@
'use client';
import React, { useState, useCallback } from 'react';
import { ChartConfig, QueryResult } from './types';
interface ChartConfigPanelProps {
config?: ChartConfig;
queryResult?: QueryResult;
onConfigChange: (config: ChartConfig) => void;
}
/**
* 차트 설정 패널 컴포넌트
* - 데이터 필드 매핑 설정
* - 차트 스타일 설정
* - 실시간 미리보기
*/
export function ChartConfigPanel({ config, queryResult, onConfigChange }: ChartConfigPanelProps) {
const [currentConfig, setCurrentConfig] = useState<ChartConfig>(config || {});
// 설정 업데이트
const updateConfig = useCallback((updates: Partial<ChartConfig>) => {
const newConfig = { ...currentConfig, ...updates };
setCurrentConfig(newConfig);
onConfigChange(newConfig);
}, [currentConfig, onConfigChange]);
// 사용 가능한 컬럼 목록
const availableColumns = queryResult?.columns || [];
const sampleData = queryResult?.rows?.[0] || {};
return (
<div className="space-y-4">
<h4 className="text-lg font-semibold text-gray-800">⚙️ 차트 설정</h4>
{/* 쿼리 결과가 없을 때 */}
{!queryResult && (
<div className="p-4 bg-yellow-50 border border-yellow-200 rounded-lg">
<div className="text-yellow-800 text-sm">
💡 먼저 SQL 쿼리를 실행하여 데이터를 가져온 후 차트를 설정할 수 있습니다.
</div>
</div>
)}
{/* 데이터 필드 매핑 */}
{queryResult && (
<>
{/* 차트 제목 */}
<div className="space-y-2">
<label className="block text-sm font-medium text-gray-700">차트 제목</label>
<input
type="text"
value={currentConfig.title || ''}
onChange={(e) => updateConfig({ title: e.target.value })}
placeholder="차트 제목을 입력하세요"
className="w-full px-3 py-2 border border-gray-300 rounded-lg text-sm"
/>
</div>
{/* X축 설정 */}
<div className="space-y-2">
<label className="block text-sm font-medium text-gray-700">
X축 (카테고리)
<span className="text-red-500 ml-1">*</span>
</label>
<select
value={currentConfig.xAxis || ''}
onChange={(e) => updateConfig({ xAxis: e.target.value })}
className="w-full px-3 py-2 border border-gray-300 rounded-lg text-sm"
>
<option value="">선택하세요</option>
{availableColumns.map((col) => (
<option key={col} value={col}>
{col} {sampleData[col] && `(예: ${sampleData[col]})`}
</option>
))}
</select>
</div>
{/* Y축 설정 (다중 선택 가능) */}
<div className="space-y-2">
<label className="block text-sm font-medium text-gray-700">
Y축 (값) - 여러 개 선택 가능
<span className="text-red-500 ml-1">*</span>
</label>
<div className="space-y-2 max-h-60 overflow-y-auto border border-gray-300 rounded-lg p-2 bg-white">
{availableColumns.map((col) => {
const isSelected = Array.isArray(currentConfig.yAxis)
? currentConfig.yAxis.includes(col)
: currentConfig.yAxis === col;
return (
<label
key={col}
className="flex items-center gap-2 p-2 hover:bg-gray-50 rounded cursor-pointer"
>
<input
type="checkbox"
checked={isSelected}
onChange={(e) => {
const currentYAxis = Array.isArray(currentConfig.yAxis)
? currentConfig.yAxis
: currentConfig.yAxis ? [currentConfig.yAxis] : [];
let newYAxis: string | string[];
if (e.target.checked) {
newYAxis = [...currentYAxis, col];
} else {
newYAxis = currentYAxis.filter(c => c !== col);
}
// 단일 값이면 문자열로, 다중 값이면 배열로
if (newYAxis.length === 1) {
newYAxis = newYAxis[0];
}
updateConfig({ yAxis: newYAxis });
}}
className="rounded"
/>
<span className="text-sm flex-1">
{col}
{sampleData[col] && (
<span className="text-gray-500 text-xs ml-2">
(예: {sampleData[col]})
</span>
)}
</span>
</label>
);
})}
</div>
<div className="text-xs text-gray-500">
💡 팁: 여러 항목을 선택하면 비교 차트가 생성됩니다 (예: 갤럭시 vs 아이폰)
</div>
</div>
{/* 집계 함수 */}
<div className="space-y-2">
<label className="block text-sm font-medium text-gray-700">
집계 함수
<span className="text-gray-500 text-xs ml-2">(데이터 처리 방식)</span>
</label>
<select
value={currentConfig.aggregation || 'sum'}
onChange={(e) => updateConfig({ aggregation: e.target.value as any })}
className="w-full px-3 py-2 border border-gray-300 rounded-lg text-sm"
>
<option value="sum">합계 (SUM) - 모든 값을 더함</option>
<option value="avg">평균 (AVG) - 평균값 계산</option>
<option value="count">개수 (COUNT) - 데이터 개수</option>
<option value="max">최대값 (MAX) - 가장 큰 값</option>
<option value="min">최소값 (MIN) - 가장 작은 값</option>
</select>
<div className="text-xs text-gray-500">
💡 집계 함수는 현재 쿼리 결과에 적용되지 않습니다.
SQL 쿼리에서 직접 집계하는 것을 권장합니다.
</div>
</div>
{/* 그룹핑 필드 (선택사항) */}
<div className="space-y-2">
<label className="block text-sm font-medium text-gray-700">
그룹핑 필드 (선택사항)
</label>
<select
value={currentConfig.groupBy || ''}
onChange={(e) => updateConfig({ groupBy: e.target.value })}
className="w-full px-3 py-2 border border-gray-300 rounded-lg text-sm"
>
<option value="">없음</option>
{availableColumns.map((col) => (
<option key={col} value={col}>
{col}
</option>
))}
</select>
</div>
{/* 차트 색상 */}
<div className="space-y-2">
<label className="block text-sm font-medium text-gray-700">차트 색상</label>
<div className="grid grid-cols-4 gap-2">
{[
['#3B82F6', '#EF4444', '#10B981', '#F59E0B'], // 기본
['#8B5CF6', '#EC4899', '#06B6D4', '#84CC16'], // 밝은
['#1F2937', '#374151', '#6B7280', '#9CA3AF'], // 회색
['#DC2626', '#EA580C', '#CA8A04', '#65A30D'], // 따뜻한
].map((colorSet, setIdx) => (
<button
key={setIdx}
onClick={() => updateConfig({ colors: colorSet })}
className={`
h-8 rounded border-2 flex
${JSON.stringify(currentConfig.colors) === JSON.stringify(colorSet)
? 'border-gray-800' : 'border-gray-300'}
`}
>
{colorSet.map((color, idx) => (
<div
key={idx}
className="flex-1 first:rounded-l last:rounded-r"
style={{ backgroundColor: color }}
/>
))}
</button>
))}
</div>
</div>
{/* 범례 표시 */}
<div className="flex items-center gap-2">
<input
type="checkbox"
id="showLegend"
checked={currentConfig.showLegend !== false}
onChange={(e) => updateConfig({ showLegend: e.target.checked })}
className="rounded"
/>
<label htmlFor="showLegend" className="text-sm text-gray-700">
범례 표시
</label>
</div>
{/* 설정 미리보기 */}
<div className="p-3 bg-gray-50 rounded-lg">
<div className="text-sm font-medium text-gray-700 mb-2">📋 설정 미리보기</div>
<div className="text-xs text-gray-600 space-y-1">
<div><strong>X축:</strong> {currentConfig.xAxis || '미설정'}</div>
<div>
<strong>Y축:</strong>{' '}
{Array.isArray(currentConfig.yAxis)
? `${currentConfig.yAxis.length}개 (${currentConfig.yAxis.join(', ')})`
: currentConfig.yAxis || '미설정'
}
</div>
<div><strong>집계:</strong> {currentConfig.aggregation || 'sum'}</div>
{currentConfig.groupBy && (
<div><strong>그룹핑:</strong> {currentConfig.groupBy}</div>
)}
<div><strong>데이터 행 수:</strong> {queryResult.rows.length}개</div>
{Array.isArray(currentConfig.yAxis) && currentConfig.yAxis.length > 1 && (
<div className="text-blue-600 mt-2">
✨ 다중 시리즈 차트가 생성됩니다!
</div>
)}
</div>
</div>
{/* 필수 필드 확인 */}
{(!currentConfig.xAxis || !currentConfig.yAxis) && (
<div className="p-3 bg-red-50 border border-red-200 rounded-lg">
<div className="text-red-800 text-sm">
⚠️ X축과 Y축을 모두 설정해야 차트가 표시됩니다.
</div>
</div>
)}
</>
)}
</div>
);
}

109
frontend/components/admin/dashboard/DashboardCanvas.tsx Normal file
View File

@ -0,0 +1,109 @@
'use client';
import React, { forwardRef, useState, useCallback } from 'react';
import { DashboardElement, ElementType, ElementSubtype, DragData } from './types';
import { CanvasElement } from './CanvasElement';
interface DashboardCanvasProps {
elements: DashboardElement[];
selectedElement: string | null;
onCreateElement: (type: ElementType, subtype: ElementSubtype, x: number, y: number) => void;
onUpdateElement: (id: string, updates: Partial<DashboardElement>) => void;
onRemoveElement: (id: string) => void;
onSelectElement: (id: string | null) => void;
onConfigureElement?: (element: DashboardElement) => void;
}
/**
* 대시보드 캔버스 컴포넌트
* - 드래그 앤 드롭 영역
* - 그리드 배경
* - 요소 배치 및 관리
*/
export const DashboardCanvas = forwardRef<HTMLDivElement, DashboardCanvasProps>(
({ elements, selectedElement, onCreateElement, onUpdateElement, onRemoveElement, onSelectElement, onConfigureElement }, ref) => {
const [isDragOver, setIsDragOver] = useState(false);
// 드래그 오버 처리
const handleDragOver = useCallback((e: React.DragEvent) => {
e.preventDefault();
e.dataTransfer.dropEffect = 'copy';
setIsDragOver(true);
}, []);
// 드래그 리브 처리
const handleDragLeave = useCallback((e: React.DragEvent) => {
if (e.currentTarget === e.target) {
setIsDragOver(false);
}
}, []);
// 드롭 처리
const handleDrop = useCallback((e: React.DragEvent) => {
e.preventDefault();
setIsDragOver(false);
try {
const dragData: DragData = JSON.parse(e.dataTransfer.getData('application/json'));
if (!ref || typeof ref === 'function') return;
const rect = ref.current?.getBoundingClientRect();
if (!rect) return;
// 캔버스 스크롤을 고려한 정확한 위치 계산
const x = e.clientX - rect.left + (ref.current?.scrollLeft || 0);
const y = e.clientY - rect.top + (ref.current?.scrollTop || 0);
onCreateElement(dragData.type, dragData.subtype, x, y);
} catch (error) {
// console.error('드롭 데이터 파싱 오류:', error);
}
}, [ref, onCreateElement]);
// 캔버스 클릭 시 선택 해제
const handleCanvasClick = useCallback((e: React.MouseEvent) => {
if (e.target === e.currentTarget) {
onSelectElement(null);
}
}, [onSelectElement]);
return (
<div
ref={ref}
className={`
w-full min-h-full relative
bg-gray-100
bg-grid-pattern
${isDragOver ? 'bg-blue-50' : ''}
`}
style={{
backgroundImage: `
linear-gradient(rgba(200, 200, 200, 0.3) 1px, transparent 1px),
linear-gradient(90deg, rgba(200, 200, 200, 0.3) 1px, transparent 1px)
`,
backgroundSize: '20px 20px'
}}
onDragOver={handleDragOver}
onDragLeave={handleDragLeave}
onDrop={handleDrop}
onClick={handleCanvasClick}
>
{/* 배치된 요소들 렌더링 */}
{elements.map((element) => (
<CanvasElement
key={element.id}
element={element}
isSelected={selectedElement === element.id}
onUpdate={onUpdateElement}
onRemove={onRemoveElement}
onSelect={onSelectElement}
onConfigure={onConfigureElement}
/>
))}
</div>
);
}
);
DashboardCanvas.displayName = 'DashboardCanvas';

297
frontend/components/admin/dashboard/DashboardDesigner.tsx Normal file
View File

@ -0,0 +1,297 @@
'use client';
import React, { useState, useRef, useCallback } from 'react';
import { DashboardCanvas } from './DashboardCanvas';
import { DashboardSidebar } from './DashboardSidebar';
import { DashboardToolbar } from './DashboardToolbar';
import { ElementConfigModal } from './ElementConfigModal';
import { DashboardElement, ElementType, ElementSubtype } from './types';
/**
* 대시보드 설계 도구 메인 컴포넌트
* - 드래그 앤 드롭으로 차트/위젯 배치
* - 요소 이동, 크기 조절, 삭제 기능
* - 레이아웃 저장/불러오기 기능
*/
export default function DashboardDesigner() {
const [elements, setElements] = useState<DashboardElement[]>([]);
const [selectedElement, setSelectedElement] = useState<string | null>(null);
const [elementCounter, setElementCounter] = useState(0);
const [configModalElement, setConfigModalElement] = useState<DashboardElement | null>(null);
const [dashboardId, setDashboardId] = useState<string | null>(null);
const [dashboardTitle, setDashboardTitle] = useState<string>('');
const [isLoading, setIsLoading] = useState(false);
const canvasRef = useRef<HTMLDivElement>(null);
// URL 파라미터에서 대시보드 ID 읽기 및 데이터 로드
React.useEffect(() => {
const params = new URLSearchParams(window.location.search);
const loadId = params.get('load');
if (loadId) {
loadDashboard(loadId);
}
}, []);
// 대시보드 데이터 로드
const loadDashboard = async (id: string) => {
setIsLoading(true);
try {
// console.log('🔄 대시보드 로딩:', id);
const { dashboardApi } = await import('@/lib/api/dashboard');
const dashboard = await dashboardApi.getDashboard(id);
// console.log('✅ 대시보드 로딩 완료:', dashboard);
// 대시보드 정보 설정
setDashboardId(dashboard.id);
setDashboardTitle(dashboard.title);
// 요소들 설정
if (dashboard.elements && dashboard.elements.length > 0) {
setElements(dashboard.elements);
// elementCounter를 가장 큰 ID 번호로 설정
const maxId = dashboard.elements.reduce((max, el) => {
const match = el.id.match(/element-(\d+)/);
if (match) {
const num = parseInt(match[1]);
return num > max ? num : max;
}
return max;
}, 0);
setElementCounter(maxId);
}
} catch (error) {
// console.error('❌ 대시보드 로딩 오류:', error);
alert('대시보드를 불러오는 중 오류가 발생했습니다.\n\n' + (error instanceof Error ? error.message : '알 수 없는 오류'));
} finally {
setIsLoading(false);
}
};
// 새로운 요소 생성
const createElement = useCallback((
type: ElementType,
subtype: ElementSubtype,
x: number,
y: number
) => {
const newElement: DashboardElement = {
id: `element-${elementCounter + 1}`,
type,
subtype,
position: { x, y },
size: { width: 250, height: 200 },
title: getElementTitle(type, subtype),
content: getElementContent(type, subtype)
};
setElements(prev => [...prev, newElement]);
setElementCounter(prev => prev + 1);
setSelectedElement(newElement.id);
}, [elementCounter]);
// 요소 업데이트
const updateElement = useCallback((id: string, updates: Partial<DashboardElement>) => {
setElements(prev => prev.map(el =>
el.id === id ? { ...el, ...updates } : el
));
}, []);
// 요소 삭제
const removeElement = useCallback((id: string) => {
setElements(prev => prev.filter(el => el.id !== id));
if (selectedElement === id) {
setSelectedElement(null);
}
}, [selectedElement]);
// 전체 삭제
const clearCanvas = useCallback(() => {
if (window.confirm('모든 요소를 삭제하시겠습니까?')) {
setElements([]);
setSelectedElement(null);
setElementCounter(0);
}
}, []);
// 요소 설정 모달 열기
const openConfigModal = useCallback((element: DashboardElement) => {
setConfigModalElement(element);
}, []);
// 요소 설정 모달 닫기
const closeConfigModal = useCallback(() => {
setConfigModalElement(null);
}, []);
// 요소 설정 저장
const saveElementConfig = useCallback((updatedElement: DashboardElement) => {
updateElement(updatedElement.id, updatedElement);
}, [updateElement]);
// 레이아웃 저장
const saveLayout = useCallback(async () => {
if (elements.length === 0) {
alert('저장할 요소가 없습니다. 차트나 위젯을 추가해주세요.');
return;
}
try {
// 실제 API 호출
const { dashboardApi } = await import('@/lib/api/dashboard');
const elementsData = elements.map(el => ({
id: el.id,
type: el.type,
subtype: el.subtype,
position: el.position,
size: el.size,
title: el.title,
content: el.content,
dataSource: el.dataSource,
chartConfig: el.chartConfig
}));
let savedDashboard;
if (dashboardId) {
// 기존 대시보드 업데이트
// console.log('🔄 대시보드 업데이트:', dashboardId);
savedDashboard = await dashboardApi.updateDashboard(dashboardId, {
elements: elementsData
});
alert(`대시보드 "${savedDashboard.title}"이 업데이트되었습니다!`);
// 뷰어 페이지로 이동
window.location.href = `/dashboard/${savedDashboard.id}`;
} else {
// 새 대시보드 생성
const title = prompt('대시보드 제목을 입력하세요:', '새 대시보드');
if (!title) return;
const description = prompt('대시보드 설명을 입력하세요 (선택사항):', '');
const dashboardData = {
title,
description: description || undefined,
isPublic: false,
elements: elementsData
};
savedDashboard = await dashboardApi.createDashboard(dashboardData);
// console.log('✅ 대시보드 생성 완료:', savedDashboard);
const viewDashboard = confirm(`대시보드 "${title}"이 저장되었습니다!\n\n지금 확인해보시겠습니까?`);
if (viewDashboard) {
window.location.href = `/dashboard/${savedDashboard.id}`;
}
}
} catch (error) {
// console.error('❌ 저장 오류:', error);
const errorMessage = error instanceof Error ? error.message : '알 수 없는 오류';
alert(`대시보드 저장 중 오류가 발생했습니다.\n\n오류: ${errorMessage}\n\n관리자에게 문의하세요.`);
}
}, [elements, dashboardId]);
// 로딩 중이면 로딩 화면 표시
if (isLoading) {
return (
<div className="flex h-full items-center justify-center bg-gray-50">
<div className="text-center">
<div className="w-12 h-12 border-4 border-blue-500 border-t-transparent rounded-full animate-spin mx-auto mb-4" />
<div className="text-lg font-medium text-gray-700">대시보드 로딩 중...</div>
<div className="text-sm text-gray-500 mt-1">잠시만 기다려주세요</div>
</div>
</div>
);
}
return (
<div className="flex h-full bg-gray-50">
{/* 캔버스 영역 */}
<div className="flex-1 relative overflow-auto border-r-2 border-gray-300">
{/* 편집 중인 대시보드 표시 */}
{dashboardTitle && (
<div className="absolute top-2 left-2 z-10 bg-blue-500 text-white px-3 py-1 rounded-lg text-sm font-medium shadow-lg">
📝 편집 중: {dashboardTitle}
</div>
)}
<DashboardToolbar
onClearCanvas={clearCanvas}
onSaveLayout={saveLayout}
/>
<DashboardCanvas
ref={canvasRef}
elements={elements}
selectedElement={selectedElement}
onCreateElement={createElement}
onUpdateElement={updateElement}
onRemoveElement={removeElement}
onSelectElement={setSelectedElement}
onConfigureElement={openConfigModal}
/>
</div>
{/* 사이드바 */}
<DashboardSidebar />
{/* 요소 설정 모달 */}
{configModalElement && (
<ElementConfigModal
element={configModalElement}
isOpen={true}
onClose={closeConfigModal}
onSave={saveElementConfig}
/>
)}
</div>
);
}
// 요소 제목 생성 헬퍼 함수
function getElementTitle(type: ElementType, subtype: ElementSubtype): string {
if (type === 'chart') {
switch (subtype) {
case 'bar': return '📊 바 차트';
case 'pie': return '🥧 원형 차트';
case 'line': return '📈 꺾은선 차트';
default: return '📊 차트';
}
} else if (type === 'widget') {
switch (subtype) {
case 'exchange': return '💱 환율 위젯';
case 'weather': return '☁️ 날씨 위젯';
default: return '🔧 위젯';
}
}
return '요소';
}
// 요소 내용 생성 헬퍼 함수
function getElementContent(type: ElementType, subtype: ElementSubtype): string {
if (type === 'chart') {
switch (subtype) {
case 'bar': return '바 차트가 여기에 표시됩니다';
case 'pie': return '원형 차트가 여기에 표시됩니다';
case 'line': return '꺾은선 차트가 여기에 표시됩니다';
default: return '차트가 여기에 표시됩니다';
}
} else if (type === 'widget') {
switch (subtype) {
case 'exchange': return 'USD: ₩1,320\nJPY: ₩900\nEUR: ₩1,450';
case 'weather': return '서울\n23°C\n구름 많음';
default: return '위젯 내용이 여기에 표시됩니다';
}
}
return '내용이 여기에 표시됩니다';
}

145
frontend/components/admin/dashboard/DashboardSidebar.tsx Normal file
View File

@ -0,0 +1,145 @@
'use client';
import React from 'react';
import { DragData, ElementType, ElementSubtype } from './types';
/**
* 대시보드 사이드바 컴포넌트
* - 드래그 가능한 차트/위젯 목록
* - 카테고리별 구분
*/
export function DashboardSidebar() {
// 드래그 시작 처리
const handleDragStart = (e: React.DragEvent, type: ElementType, subtype: ElementSubtype) => {
const dragData: DragData = { type, subtype };
e.dataTransfer.setData('application/json', JSON.stringify(dragData));
e.dataTransfer.effectAllowed = 'copy';
};
return (
<div className="w-80 bg-white border-l border-gray-200 overflow-y-auto p-5">
{/* 차트 섹션 */}
<div className="mb-8">
<h3 className="text-gray-800 mb-4 pb-3 border-b-2 border-green-500 font-semibold text-lg">
📊 차트 종류
</h3>
<div className="space-y-3">
<DraggableItem
icon="📊"
title="바 차트"
type="chart"
subtype="bar"
onDragStart={handleDragStart}
className="border-l-4 border-blue-500"
/>
<DraggableItem
icon="📚"
title="누적 바 차트"
type="chart"
subtype="stacked-bar"
onDragStart={handleDragStart}
className="border-l-4 border-blue-600"
/>
<DraggableItem
icon="📈"
title="꺾은선 차트"
type="chart"
subtype="line"
onDragStart={handleDragStart}
className="border-l-4 border-green-500"
/>
<DraggableItem
icon="📉"
title="영역 차트"
type="chart"
subtype="area"
onDragStart={handleDragStart}
className="border-l-4 border-green-600"
/>
<DraggableItem
icon="🥧"
title="원형 차트"
type="chart"
subtype="pie"
onDragStart={handleDragStart}
className="border-l-4 border-purple-500"
/>
<DraggableItem
icon="🍩"
title="도넛 차트"
type="chart"
subtype="donut"
onDragStart={handleDragStart}
className="border-l-4 border-purple-600"
/>
<DraggableItem
icon="📊📈"
title="콤보 차트"
type="chart"
subtype="combo"
onDragStart={handleDragStart}
className="border-l-4 border-indigo-500"
/>
</div>
</div>
{/* 위젯 섹션 */}
<div className="mb-8">
<h3 className="text-gray-800 mb-4 pb-3 border-b-2 border-green-500 font-semibold text-lg">
🔧 위젯 종류
</h3>
<div className="space-y-3">
<DraggableItem
icon="💱"
title="환율 위젯"
type="widget"
subtype="exchange"
onDragStart={handleDragStart}
className="border-l-4 border-orange-500"
/>
<DraggableItem
icon="☁️"
title="날씨 위젯"
type="widget"
subtype="weather"
onDragStart={handleDragStart}
className="border-l-4 border-orange-500"
/>
</div>
</div>
</div>
);
}
interface DraggableItemProps {
icon: string;
title: string;
type: ElementType;
subtype: ElementSubtype;
className?: string;
onDragStart: (e: React.DragEvent, type: ElementType, subtype: ElementSubtype) => void;
}
/**
* 드래그 가능한 아이템 컴포넌트
*/
function DraggableItem({ icon, title, type, subtype, className = '', onDragStart }: DraggableItemProps) {
return (
<div
draggable
className={`
p-4 bg-white border-2 border-gray-200 rounded-lg
cursor-move transition-all duration-200
hover:bg-gray-50 hover:border-green-500 hover:translate-x-1
text-center text-sm font-medium
${className}
`}
onDragStart={(e) => onDragStart(e, type, subtype)}
>
<span className="text-lg mr-2">{icon}</span>
{title}
</div>
);
}

42
frontend/components/admin/dashboard/DashboardToolbar.tsx Normal file
View File

@ -0,0 +1,42 @@
'use client';
import React from 'react';
interface DashboardToolbarProps {
onClearCanvas: () => void;
onSaveLayout: () => void;
}
/**
* 대시보드 툴바 컴포넌트
* - 전체 삭제, 레이아웃 저장 등 주요 액션 버튼
*/
export function DashboardToolbar({ onClearCanvas, onSaveLayout }: DashboardToolbarProps) {
return (
<div className="absolute top-5 left-5 bg-white p-3 rounded-lg shadow-lg z-50 flex gap-3">
<button
onClick={onClearCanvas}
className="
px-4 py-2 border border-gray-300 bg-white rounded-md
text-sm font-medium text-gray-700
hover:bg-gray-50 hover:border-gray-400
transition-colors duration-200
"
>
🗑️ 전체 삭제
</button>
<button
onClick={onSaveLayout}
className="
px-4 py-2 border border-gray-300 bg-white rounded-md
text-sm font-medium text-gray-700
hover:bg-gray-50 hover:border-gray-400
transition-colors duration-200
"
>
💾 레이아웃 저장
</button>
</div>
);
}

169
frontend/components/admin/dashboard/ElementConfigModal.tsx Normal file
View File

@ -0,0 +1,169 @@
'use client';
import React, { useState, useCallback } from 'react';
import { DashboardElement, ChartDataSource, ChartConfig, QueryResult } from './types';
import { QueryEditor } from './QueryEditor';
import { ChartConfigPanel } from './ChartConfigPanel';
interface ElementConfigModalProps {
element: DashboardElement;
isOpen: boolean;
onClose: () => void;
onSave: (element: DashboardElement) => void;
}
/**
* 요소 설정 모달 컴포넌트
* - 차트/위젯 데이터 소스 설정
* - 쿼리 에디터 통합
* - 차트 설정 패널 통합
*/
export function ElementConfigModal({ element, isOpen, onClose, onSave }: ElementConfigModalProps) {
const [dataSource, setDataSource] = useState<ChartDataSource>(
element.dataSource || { type: 'database', refreshInterval: 30000 }
);
const [chartConfig, setChartConfig] = useState<ChartConfig>(
element.chartConfig || {}
);
const [queryResult, setQueryResult] = useState<QueryResult | null>(null);
const [activeTab, setActiveTab] = useState<'query' | 'chart'>('query');
// 데이터 소스 변경 처리
const handleDataSourceChange = useCallback((newDataSource: ChartDataSource) => {
setDataSource(newDataSource);
}, []);
// 차트 설정 변경 처리
const handleChartConfigChange = useCallback((newConfig: ChartConfig) => {
setChartConfig(newConfig);
}, []);
// 쿼리 테스트 결과 처리
const handleQueryTest = useCallback((result: QueryResult) => {
setQueryResult(result);
// 쿼리 결과가 나오면 자동으로 차트 설정 탭으로 이동
if (result.rows.length > 0) {
setActiveTab('chart');
}
}, []);
// 저장 처리
const handleSave = useCallback(() => {
const updatedElement: DashboardElement = {
...element,
dataSource,
chartConfig,
};
onSave(updatedElement);
onClose();
}, [element, dataSource, chartConfig, onSave, onClose]);
// 모달이 열려있지 않으면 렌더링하지 않음
if (!isOpen) return null;
return (
<div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
<div className="bg-white rounded-lg shadow-xl w-full max-w-4xl h-[80vh] flex flex-col">
{/* 모달 헤더 */}
<div className="flex justify-between items-center p-6 border-b border-gray-200">
<div>
<h2 className="text-xl font-semibold text-gray-800">
{element.title} 설정
</h2>
<p className="text-sm text-gray-600 mt-1">
데이터 소스와 차트 설정을 구성하세요
</p>
</div>
<button
onClick={onClose}
className="text-gray-400 hover:text-gray-600 text-2xl"
>
×
</button>
</div>
{/* 탭 네비게이션 */}
<div className="flex border-b border-gray-200">
<button
onClick={() => setActiveTab('query')}
className={`
px-6 py-3 text-sm font-medium border-b-2 transition-colors
${activeTab === 'query'
? 'border-blue-500 text-blue-600 bg-blue-50'
: 'border-transparent text-gray-500 hover:text-gray-700'}
`}
>
📝 쿼리 & 데이터
</button>
<button
onClick={() => setActiveTab('chart')}
className={`
px-6 py-3 text-sm font-medium border-b-2 transition-colors
${activeTab === 'chart'
? 'border-blue-500 text-blue-600 bg-blue-50'
: 'border-transparent text-gray-500 hover:text-gray-700'}
`}
>
📊 차트 설정
{queryResult && (
<span className="ml-2 px-2 py-0.5 bg-green-100 text-green-800 text-xs rounded-full">
{queryResult.rows.length}
</span>
)}
</button>
</div>
{/* 탭 내용 */}
<div className="flex-1 overflow-auto p-6">
{activeTab === 'query' && (
<QueryEditor
dataSource={dataSource}
onDataSourceChange={handleDataSourceChange}
onQueryTest={handleQueryTest}
/>
)}
{activeTab === 'chart' && (
<ChartConfigPanel
config={chartConfig}
queryResult={queryResult}
onConfigChange={handleChartConfigChange}
/>
)}
</div>
{/* 모달 푸터 */}
<div className="flex justify-between items-center p-6 border-t border-gray-200">
<div className="text-sm text-gray-500">
{dataSource.query && (
<>
💾 쿼리: {dataSource.query.length > 50
? `${dataSource.query.substring(0, 50)}...`
: dataSource.query}
</>
)}
</div>
<div className="flex gap-3">
<button
onClick={onClose}
className="px-4 py-2 text-gray-600 border border-gray-300 rounded-lg hover:bg-gray-50"
>
취소
</button>
<button
onClick={handleSave}
disabled={!dataSource.query || (!chartConfig.xAxis || !chartConfig.yAxis)}
className="
px-4 py-2 bg-blue-500 text-white rounded-lg
hover:bg-blue-600 disabled:bg-gray-300 disabled:cursor-not-allowed
"
>
저장
</button>
</div>
</div>
</div>
</div>
);
}

489
frontend/components/admin/dashboard/QueryEditor.tsx Normal file
View File

@ -0,0 +1,489 @@
'use client';
import React, { useState, useCallback } from 'react';
import { ChartDataSource, QueryResult } from './types';
interface QueryEditorProps {
dataSource?: ChartDataSource;
onDataSourceChange: (dataSource: ChartDataSource) => void;
onQueryTest?: (result: QueryResult) => void;
}
/**
* SQL 쿼리 에디터 컴포넌트
* - SQL 쿼리 작성 및 편집
* - 쿼리 실행 및 결과 미리보기
* - 데이터 소스 설정
*/
export function QueryEditor({ dataSource, onDataSourceChange, onQueryTest }: QueryEditorProps) {
const [query, setQuery] = useState(dataSource?.query || '');
const [isExecuting, setIsExecuting] = useState(false);
const [queryResult, setQueryResult] = useState<QueryResult | null>(null);
const [error, setError] = useState<string | null>(null);
// 쿼리 실행
const executeQuery = useCallback(async () => {
if (!query.trim()) {
setError('쿼리를 입력해주세요.');
return;
}
setIsExecuting(true);
setError(null);
try {
// 실제 API 호출
const response = await fetch('http://localhost:8080/api/dashboards/execute-query', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${localStorage.getItem('token') || 'test-token'}` // JWT 토큰 사용
},
body: JSON.stringify({ query: query.trim() })
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.message || '쿼리 실행에 실패했습니다.');
}
const apiResult = await response.json();
if (!apiResult.success) {
throw new Error(apiResult.message || '쿼리 실행에 실패했습니다.');
}
// API 결과를 QueryResult 형식으로 변환
const result: QueryResult = {
columns: apiResult.data.columns,
rows: apiResult.data.rows,
totalRows: apiResult.data.rowCount,
executionTime: 0 // API에서 실행 시간을 제공하지 않으므로 0으로 설정
};
setQueryResult(result);
onQueryTest?.(result);
// 데이터 소스 업데이트
onDataSourceChange({
type: 'database',
query: query.trim(),
refreshInterval: dataSource?.refreshInterval || 30000,
lastExecuted: new Date().toISOString()
});
} catch (err) {
const errorMessage = err instanceof Error ? err.message : '쿼리 실행 중 오류가 발생했습니다.';
setError(errorMessage);
// console.error('Query execution error:', err);
} finally {
setIsExecuting(false);
}
}, [query, dataSource?.refreshInterval, onDataSourceChange, onQueryTest]);
// 샘플 쿼리 삽입
const insertSampleQuery = useCallback((sampleType: string) => {
const samples = {
comparison: `-- 제품별 월별 매출 비교 (다중 시리즈)
-- 갤럭시(Galaxy) vs 아이폰(iPhone) 매출 비교
SELECT
DATE_TRUNC('month', order_date) as month,
SUM(CASE WHEN product_category = '갤럭시' THEN amount ELSE 0 END) as galaxy_sales,
SUM(CASE WHEN product_category = '아이폰' THEN amount ELSE 0 END) as iphone_sales,
SUM(CASE WHEN product_category = '기타' THEN amount ELSE 0 END) as other_sales
FROM orders
WHERE order_date >= CURRENT_DATE - INTERVAL '12 months'
GROUP BY DATE_TRUNC('month', order_date)
ORDER BY month;`,
sales: `-- 월별 매출 데이터
SELECT
DATE_TRUNC('month', order_date) as month,
SUM(total_amount) as sales,
COUNT(*) as order_count
FROM orders
WHERE order_date >= CURRENT_DATE - INTERVAL '12 months'
GROUP BY DATE_TRUNC('month', order_date)
ORDER BY month;`,
users: `-- 사용자 가입 추이
SELECT
DATE_TRUNC('week', created_at) as week,
COUNT(*) as new_users
FROM users
WHERE created_at >= CURRENT_DATE - INTERVAL '3 months'
GROUP BY DATE_TRUNC('week', created_at)
ORDER BY week;`,
products: `-- 상품별 판매량
SELECT
product_name,
SUM(quantity) as total_sold,
SUM(quantity * price) as revenue
FROM order_items oi
JOIN products p ON oi.product_id = p.id
WHERE oi.created_at >= CURRENT_DATE - INTERVAL '1 month'
GROUP BY product_name
ORDER BY total_sold DESC
LIMIT 10;`,
regional: `-- 지역별 매출 비교
SELECT
region as 지역,
SUM(CASE WHEN quarter = 'Q1' THEN sales ELSE 0 END) as Q1,
SUM(CASE WHEN quarter = 'Q2' THEN sales ELSE 0 END) as Q2,
SUM(CASE WHEN quarter = 'Q3' THEN sales ELSE 0 END) as Q3,
SUM(CASE WHEN quarter = 'Q4' THEN sales ELSE 0 END) as Q4
FROM regional_sales
WHERE year = EXTRACT(YEAR FROM CURRENT_DATE)
GROUP BY region
ORDER BY Q4 DESC;`
};
setQuery(samples[sampleType as keyof typeof samples] || '');
}, []);
return (
<div className="space-y-4">
{/* 쿼리 에디터 헤더 */}
<div className="flex justify-between items-center">
<h4 className="text-lg font-semibold text-gray-800">📝 SQL 쿼리 에디터</h4>
<div className="flex gap-2">
<button
onClick={executeQuery}
disabled={isExecuting || !query.trim()}
className="
px-3 py-1 bg-blue-500 text-white rounded text-sm
hover:bg-blue-600 disabled:bg-gray-300 disabled:cursor-not-allowed
flex items-center gap-1
"
>
{isExecuting ? (
<>
<div className="w-3 h-3 border border-white border-t-transparent rounded-full animate-spin" />
실행 중...
</>
) : (
<>▶ 실행</>
)}
</button>
</div>
</div>
{/* 샘플 쿼리 버튼들 */}
<div className="flex gap-2 flex-wrap">
<span className="text-sm text-gray-600">샘플 쿼리:</span>
<button
onClick={() => insertSampleQuery('comparison')}
className="px-2 py-1 text-xs bg-blue-100 hover:bg-blue-200 rounded font-medium"
>
🔥 제품 비교
</button>
<button
onClick={() => insertSampleQuery('regional')}
className="px-2 py-1 text-xs bg-green-100 hover:bg-green-200 rounded font-medium"
>
🌍 지역별 비교
</button>
<button
onClick={() => insertSampleQuery('sales')}
className="px-2 py-1 text-xs bg-gray-100 hover:bg-gray-200 rounded"
>
매출 데이터
</button>
<button
onClick={() => insertSampleQuery('users')}
className="px-2 py-1 text-xs bg-gray-100 hover:bg-gray-200 rounded"
>
사용자 추이
</button>
<button
onClick={() => insertSampleQuery('products')}
className="px-2 py-1 text-xs bg-gray-100 hover:bg-gray-200 rounded"
>
상품 판매량
</button>
</div>
{/* SQL 쿼리 입력 영역 */}
<div className="relative">
<textarea
value={query}
onChange={(e) => setQuery(e.target.value)}
placeholder="SELECT * FROM your_table WHERE condition = 'value';"
className="
w-full h-40 p-3 border border-gray-300 rounded-lg
font-mono text-sm resize-none
focus:ring-2 focus:ring-blue-500 focus:border-transparent
"
/>
<div className="absolute bottom-2 right-2 text-xs text-gray-400">
Ctrl+Enter로 실행
</div>
</div>
{/* 새로고침 간격 설정 */}
<div className="flex items-center gap-3">
<label className="text-sm text-gray-600">자동 새로고침:</label>
<select
value={dataSource?.refreshInterval || 30000}
onChange={(e) => onDataSourceChange({
...dataSource,
type: 'database',
query,
refreshInterval: parseInt(e.target.value)
})}
className="px-2 py-1 border border-gray-300 rounded text-sm"
>
<option value={0}>수동</option>
<option value={10000}>10초</option>
<option value={30000}>30초</option>
<option value={60000}>1분</option>
<option value={300000}>5분</option>
<option value={600000}>10분</option>
</select>
</div>
{/* 오류 메시지 */}
{error && (
<div className="p-3 bg-red-50 border border-red-200 rounded-lg">
<div className="text-red-800 text-sm font-medium">❌ 오류</div>
<div className="text-red-700 text-sm mt-1">{error}</div>
</div>
)}
{/* 쿼리 결과 미리보기 */}
{queryResult && (
<div className="border border-gray-200 rounded-lg">
<div className="bg-gray-50 px-3 py-2 border-b border-gray-200">
<div className="flex justify-between items-center">
<span className="text-sm font-medium text-gray-700">
📊 쿼리 결과 ({queryResult.rows.length}행)
</span>
<span className="text-xs text-gray-500">
실행 시간: {queryResult.executionTime}ms
</span>
</div>
</div>
<div className="p-3 max-h-60 overflow-auto">
{queryResult.rows.length > 0 ? (
<table className="w-full text-sm">
<thead>
<tr className="border-b border-gray-200">
{queryResult.columns.map((col, idx) => (
<th key={idx} className="text-left py-1 px-2 font-medium text-gray-700">
{col}
</th>
))}
</tr>
</thead>
<tbody>
{queryResult.rows.slice(0, 10).map((row, idx) => (
<tr key={idx} className="border-b border-gray-100">
{queryResult.columns.map((col, colIdx) => (
<td key={colIdx} className="py-1 px-2 text-gray-600">
{String(row[col] ?? '')}
</td>
))}
</tr>
))}
</tbody>
</table>
) : (
<div className="text-center text-gray-500 py-4">
결과가 없습니다.
</div>
)}
{queryResult.rows.length > 10 && (
<div className="text-center text-xs text-gray-500 mt-2">
... 및 {queryResult.rows.length - 10}개 더 (미리보기는 10행까지만 표시)
</div>
)}
</div>
</div>
)}
{/* 키보드 단축키 안내 */}
<div className="text-xs text-gray-500 bg-gray-50 p-2 rounded">
💡 <strong>단축키:</strong> Ctrl+Enter (쿼리 실행), Ctrl+/ (주석 토글)
</div>
</div>
);
// Ctrl+Enter로 쿼리 실행
React.useEffect(() => {
const handleKeyDown = (e: KeyboardEvent) => {
if (e.ctrlKey && e.key === 'Enter') {
e.preventDefault();
executeQuery();
}
};
document.addEventListener('keydown', handleKeyDown);
return () => document.removeEventListener('keydown', handleKeyDown);
}, [executeQuery]);
}
/**
* 샘플 쿼리 결과 생성 함수
*/
function generateSampleQueryResult(query: string): QueryResult {
// 쿼리에서 키워드 추출하여 적절한 샘플 데이터 생성
const queryLower = query.toLowerCase();
// 디버깅용 로그
// console.log('generateSampleQueryResult called with query:', query.substring(0, 100));
// 가장 구체적인 조건부터 먼저 체크 (순서 중요!)
const isComparison = queryLower.includes('galaxy') || queryLower.includes('갤럭시') || queryLower.includes('아이폰') || queryLower.includes('iphone');
const isRegional = queryLower.includes('region') || queryLower.includes('지역');
const isMonthly = queryLower.includes('month');
const isSales = queryLower.includes('sales') || queryLower.includes('매출');
const isUsers = queryLower.includes('users') || queryLower.includes('사용자');
const isProducts = queryLower.includes('product') || queryLower.includes('상품');
const isWeekly = queryLower.includes('week');
// console.log('Sample data type detection:', {
// isComparison,
// isRegional,
// isWeekly,
// isProducts,
// isMonthly,
// isSales,
// isUsers,
// querySnippet: query.substring(0, 200)
// });
let columns: string[];
let rows: Record<string, any>[];
// 더 구체적인 조건부터 먼저 체크 (순서 중요!)
if (isComparison) {
// console.log('✅ Using COMPARISON data');
// 제품 비교 데이터 (다중 시리즈)
columns = ['month', 'galaxy_sales', 'iphone_sales', 'other_sales'];
rows = [
{ month: '2024-01', galaxy_sales: 450000, iphone_sales: 620000, other_sales: 130000 },
{ month: '2024-02', galaxy_sales: 520000, iphone_sales: 680000, other_sales: 150000 },
{ month: '2024-03', galaxy_sales: 480000, iphone_sales: 590000, other_sales: 110000 },
{ month: '2024-04', galaxy_sales: 610000, iphone_sales: 650000, other_sales: 160000 },
{ month: '2024-05', galaxy_sales: 720000, iphone_sales: 780000, other_sales: 180000 },
{ month: '2024-06', galaxy_sales: 680000, iphone_sales: 690000, other_sales: 170000 },
{ month: '2024-07', galaxy_sales: 750000, iphone_sales: 800000, other_sales: 170000 },
{ month: '2024-08', galaxy_sales: 690000, iphone_sales: 720000, other_sales: 170000 },
{ month: '2024-09', galaxy_sales: 730000, iphone_sales: 750000, other_sales: 170000 },
{ month: '2024-10', galaxy_sales: 800000, iphone_sales: 810000, other_sales: 170000 },
{ month: '2024-11', galaxy_sales: 870000, iphone_sales: 880000, other_sales: 170000 },
{ month: '2024-12', galaxy_sales: 950000, iphone_sales: 990000, other_sales: 160000 },
];
// COMPARISON 데이터를 반환하고 함수 종료
// console.log('COMPARISON data generated:', {
// columns,
// rowCount: rows.length,
// sampleRow: rows[0],
// allRows: rows,
// fieldTypes: {
// month: typeof rows[0].month,
// galaxy_sales: typeof rows[0].galaxy_sales,
// iphone_sales: typeof rows[0].iphone_sales,
// other_sales: typeof rows[0].other_sales
// },
// firstFewRows: rows.slice(0, 3),
// lastFewRows: rows.slice(-3)
// });
return {
columns,
rows,
totalRows: rows.length,
executionTime: Math.floor(Math.random() * 200) + 100,
};
} else if (isRegional) {
// console.log('✅ Using REGIONAL data');
// 지역별 분기별 매출
columns = ['지역', 'Q1', 'Q2', 'Q3', 'Q4'];
rows = [
{ 지역: '서울', Q1: 1200000, Q2: 1350000, Q3: 1420000, Q4: 1580000 },
{ 지역: '경기', Q1: 980000, Q2: 1120000, Q3: 1180000, Q4: 1290000 },
{ 지역: '부산', Q1: 650000, Q2: 720000, Q3: 780000, Q4: 850000 },
{ 지역: '대구', Q1: 450000, Q2: 490000, Q3: 520000, Q4: 580000 },
{ 지역: '인천', Q1: 520000, Q2: 580000, Q3: 620000, Q4: 690000 },
{ 지역: '광주', Q1: 380000, Q2: 420000, Q3: 450000, Q4: 490000 },
{ 지역: '대전', Q1: 410000, Q2: 460000, Q3: 490000, Q4: 530000 },
];
} else if (isWeekly && isUsers) {
// console.log('✅ Using USERS data');
// 사용자 가입 추이
columns = ['week', 'new_users'];
rows = [
{ week: '2024-W10', new_users: 23 },
{ week: '2024-W11', new_users: 31 },
{ week: '2024-W12', new_users: 28 },
{ week: '2024-W13', new_users: 35 },
{ week: '2024-W14', new_users: 42 },
{ week: '2024-W15', new_users: 38 },
{ week: '2024-W16', new_users: 45 },
{ week: '2024-W17', new_users: 52 },
{ week: '2024-W18', new_users: 48 },
{ week: '2024-W19', new_users: 55 },
{ week: '2024-W20', new_users: 61 },
{ week: '2024-W21', new_users: 58 },
];
} else if (isProducts && !isComparison) {
// console.log('✅ Using PRODUCTS data');
// 상품별 판매량
columns = ['product_name', 'total_sold', 'revenue'];
rows = [
{ product_name: '스마트폰', total_sold: 156, revenue: 234000000 },
{ product_name: '노트북', total_sold: 89, revenue: 178000000 },
{ product_name: '태블릿', total_sold: 134, revenue: 67000000 },
{ product_name: '이어폰', total_sold: 267, revenue: 26700000 },
{ product_name: '스마트워치', total_sold: 98, revenue: 49000000 },
{ product_name: '키보드', total_sold: 78, revenue: 15600000 },
{ product_name: '마우스', total_sold: 145, revenue: 8700000 },
{ product_name: '모니터', total_sold: 67, revenue: 134000000 },
{ product_name: '프린터', total_sold: 34, revenue: 17000000 },
{ product_name: '웹캠', total_sold: 89, revenue: 8900000 },
];
} else if (isMonthly && isSales && !isComparison) {
// console.log('✅ Using MONTHLY SALES data');
// 월별 매출 데이터
columns = ['month', 'sales', 'order_count'];
rows = [
{ month: '2024-01', sales: 1200000, order_count: 45 },
{ month: '2024-02', sales: 1350000, order_count: 52 },
{ month: '2024-03', sales: 1180000, order_count: 41 },
{ month: '2024-04', sales: 1420000, order_count: 58 },
{ month: '2024-05', sales: 1680000, order_count: 67 },
{ month: '2024-06', sales: 1540000, order_count: 61 },
{ month: '2024-07', sales: 1720000, order_count: 71 },
{ month: '2024-08', sales: 1580000, order_count: 63 },
{ month: '2024-09', sales: 1650000, order_count: 68 },
{ month: '2024-10', sales: 1780000, order_count: 75 },
{ month: '2024-11', sales: 1920000, order_count: 82 },
{ month: '2024-12', sales: 2100000, order_count: 89 },
];
} else {
// console.log('⚠️ Using DEFAULT data');
// 기본 샘플 데이터
columns = ['category', 'value', 'count'];
rows = [
{ category: 'A', value: 100, count: 10 },
{ category: 'B', value: 150, count: 15 },
{ category: 'C', value: 120, count: 12 },
{ category: 'D', value: 180, count: 18 },
{ category: 'E', value: 90, count: 9 },
{ category: 'F', value: 200, count: 20 },
{ category: 'G', value: 110, count: 11 },
{ category: 'H', value: 160, count: 16 },
];
}
return {
columns,
rows,
totalRows: rows.length,
executionTime: Math.floor(Math.random() * 200) + 100, // 100-300ms
};
}

110
frontend/components/admin/dashboard/charts/AreaChartComponent.tsx Normal file
View File

@ -0,0 +1,110 @@
'use client';
import React from 'react';
import {
AreaChart,
Area,
XAxis,
YAxis,
CartesianGrid,
Tooltip,
Legend,
ResponsiveContainer
} from 'recharts';
import { ChartConfig } from '../types';
interface AreaChartComponentProps {
data: any[];
config: ChartConfig;
width?: number;
height?: number;
}
/**
* 영역 차트 컴포넌트
* - Recharts AreaChart 사용
* - 추세 파악에 적합
* - 다중 시리즈 지원
*/
export function AreaChartComponent({ data, config, width = 250, height = 200 }: AreaChartComponentProps) {
const {
xAxis = 'x',
yAxis = 'y',
colors = ['#3B82F6', '#EF4444', '#10B981', '#F59E0B'],
title,
showLegend = true
} = config;
// Y축 필드들 (단일 또는 다중)
const yFields = Array.isArray(yAxis) ? yAxis : [yAxis];
const yKeys = yFields.filter(field => field && field !== 'y');
return (
<div className="w-full h-full p-2">
{title && (
<div className="text-center text-sm font-semibold text-gray-700 mb-2">
{title}
</div>
)}
<ResponsiveContainer width="100%" height="100%">
<AreaChart
data={data}
margin={{
top: 5,
right: 30,
left: 20,
bottom: 5,
}}
>
<defs>
{yKeys.map((key, index) => (
<linearGradient key={key} id={`color${index}`} x1="0" y1="0" x2="0" y2="1">
<stop offset="5%" stopColor={colors[index % colors.length]} stopOpacity={0.8}/>
<stop offset="95%" stopColor={colors[index % colors.length]} stopOpacity={0.1}/>
</linearGradient>
))}
</defs>
<CartesianGrid strokeDasharray="3 3" stroke="#f0f0f0" />
<XAxis
dataKey={xAxis}
tick={{ fontSize: 12 }}
stroke="#666"
/>
<YAxis
tick={{ fontSize: 12 }}
stroke="#666"
/>
<Tooltip
contentStyle={{
backgroundColor: 'white',
border: '1px solid #ccc',
borderRadius: '4px',
fontSize: '12px'
}}
formatter={(value: any, name: string) => [
typeof value === 'number' ? value.toLocaleString() : value,
name
]}
/>
{showLegend && yKeys.length > 1 && (
<Legend
wrapperStyle={{ fontSize: '12px' }}
/>
)}
{yKeys.map((key, index) => (
<Area
key={key}
type="monotone"
dataKey={key}
stroke={colors[index % colors.length]}
fill={`url(#color${index})`}
strokeWidth={2}
/>
))}
</AreaChart>
</ResponsiveContainer>
</div>
);
}

87
frontend/components/admin/dashboard/charts/BarChartComponent.tsx Normal file
View File

@ -0,0 +1,87 @@
'use client';
import React from 'react';
import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } from 'recharts';
interface BarChartComponentProps {
data: any[];
config: any;
width?: number;
height?: number;
}
/**
* 바 차트 컴포넌트 (Recharts SimpleBarChart 기반)
* - 실제 데이터를 받아서 단순하게 표시
* - 복잡한 변환 로직 없음
*/
export function BarChartComponent({ data, config, width = 600, height = 300 }: BarChartComponentProps) {
// console.log('🎨 BarChartComponent - 전체 데이터:', {
// dataLength: data?.length,
// fullData: data,
// dataType: typeof data,
// isArray: Array.isArray(data),
// config,
// xAxisField: config?.xAxis,
// yAxisFields: config?.yAxis
// });
// 데이터가 없으면 메시지 표시
if (!data || data.length === 0) {
return (
<div className="w-full h-full flex items-center justify-center text-gray-500">
<div className="text-center">
<div className="text-2xl mb-2">📊</div>
<div>데이터가 없습니다</div>
</div>
</div>
);
}
// 데이터의 첫 번째 아이템에서 사용 가능한 키 확인
const firstItem = data[0];
const availableKeys = Object.keys(firstItem);
// console.log('📊 사용 가능한 데이터 키:', availableKeys);
// console.log('📊 첫 번째 데이터 아이템:', firstItem);
// Y축 필드 추출 (배열이면 모두 사용, 아니면 단일 값)
const yFields = Array.isArray(config.yAxis) ? config.yAxis : [config.yAxis];
// 색상 배열
const colors = ['#8884d8', '#82ca9d', '#ffc658', '#ff7c7c', '#8dd1e1'];
// 한글 레이블 매핑
const labelMapping: Record<string, string> = {
'total_users': '전체 사용자',
'active_users': '활성 사용자',
'name': '부서'
};
return (
<ResponsiveContainer width="100%" height="100%">
<BarChart
data={data}
margin={{ top: 5, right: 30, left: 20, bottom: 5 }}
>
<CartesianGrid strokeDasharray="3 3" />
<XAxis
dataKey={config.xAxis}
tick={{ fontSize: 12 }}
/>
<YAxis tick={{ fontSize: 12 }} />
<Tooltip />
{config.showLegend !== false && <Legend />}
{/* Y축 필드마다 Bar 생성 */}
{yFields.map((field: string, index: number) => (
<Bar
key={field}
dataKey={field}
fill={colors[index % colors.length]}
name={labelMapping[field] || field}
/>
))}
</BarChart>
</ResponsiveContainer>
);
}

102
frontend/components/admin/dashboard/charts/ChartRenderer.tsx Normal file
View File

@ -0,0 +1,102 @@
'use client';
import React from 'react';
import { DashboardElement, QueryResult } from '../types';
import { BarChartComponent } from './BarChartComponent';
import { PieChartComponent } from './PieChartComponent';
import { LineChartComponent } from './LineChartComponent';
import { AreaChartComponent } from './AreaChartComponent';
import { StackedBarChartComponent } from './StackedBarChartComponent';
import { DonutChartComponent } from './DonutChartComponent';
import { ComboChartComponent } from './ComboChartComponent';
interface ChartRendererProps {
element: DashboardElement;
data?: QueryResult;
width?: number;
height?: number;
}
/**
* 차트 렌더러 컴포넌트 (단순 버전)
* - 데이터를 받아서 차트에 그대로 전달
* - 복잡한 변환 로직 제거
*/
export function ChartRenderer({ element, data, width = 250, height = 200 }: ChartRendererProps) {
// console.log('🎬 ChartRenderer:', {
// elementId: element.id,
// hasData: !!data,
// dataRows: data?.rows?.length,
// xAxis: element.chartConfig?.xAxis,
// yAxis: element.chartConfig?.yAxis
// });
// 데이터나 설정이 없으면 메시지 표시
if (!data || !element.chartConfig?.xAxis || !element.chartConfig?.yAxis) {
return (
<div className="w-full h-full flex items-center justify-center text-gray-500 text-sm">
<div className="text-center">
<div className="text-2xl mb-2">📊</div>
<div>데이터를 설정해주세요</div>
<div className="text-xs mt-1">⚙️ 버튼을 클릭하여 설정</div>
</div>
</div>
);
}
// 데이터가 비어있으면
if (!data.rows || data.rows.length === 0) {
return (
<div className="w-full h-full flex items-center justify-center text-red-500 text-sm">
<div className="text-center">
<div className="text-2xl mb-2">⚠️</div>
<div>데이터가 없습니다</div>
</div>
</div>
);
}
// 데이터를 그대로 전달 (변환 없음!)
const chartData = data.rows;
// console.log('📊 Chart Data:', {
// dataLength: chartData.length,
// firstRow: chartData[0],
// columns: Object.keys(chartData[0] || {})
// });
// 차트 공통 props
const chartProps = {
data: chartData,
config: element.chartConfig,
width: width - 20,
height: height - 60,
};
// 차트 타입에 따른 렌더링
switch (element.subtype) {
case 'bar':
return <BarChartComponent {...chartProps} />;
case 'pie':
return <PieChartComponent {...chartProps} />;
case 'line':
return <LineChartComponent {...chartProps} />;
case 'area':
return <AreaChartComponent {...chartProps} />;
case 'stacked-bar':
return <StackedBarChartComponent {...chartProps} />;
case 'donut':
return <DonutChartComponent {...chartProps} />;
case 'combo':
return <ComboChartComponent {...chartProps} />;
default:
return (
<div className="w-full h-full flex items-center justify-center text-gray-500 text-sm">
<div className="text-center">
<div className="text-2xl mb-2">❓</div>
<div>지원하지 않는 차트 타입</div>
</div>
</div>
);
}
}

118
frontend/components/admin/dashboard/charts/ComboChartComponent.tsx Normal file
View File

@ -0,0 +1,118 @@
'use client';
import React from 'react';
import {
ComposedChart,
Bar,
Line,
XAxis,
YAxis,
CartesianGrid,
Tooltip,
Legend,
ResponsiveContainer
} from 'recharts';
import { ChartConfig } from '../types';
interface ComboChartComponentProps {
data: any[];
config: ChartConfig;
width?: number;
height?: number;
}
/**
* 콤보 차트 컴포넌트 (바 + 라인)
* - Recharts ComposedChart 사용
* - 서로 다른 스케일의 데이터를 함께 표시
* - 예: 매출(바) + 이익률(라인)
*/
export function ComboChartComponent({ data, config, width = 250, height = 200 }: ComboChartComponentProps) {
const {
xAxis = 'x',
yAxis = 'y',
colors = ['#3B82F6', '#EF4444', '#10B981', '#F59E0B'],
title,
showLegend = true
} = config;
// Y축 필드들 (단일 또는 다중)
const yFields = Array.isArray(yAxis) ? yAxis : [yAxis];
const yKeys = yFields.filter(field => field && field !== 'y');
// 첫 번째는 Bar, 나머지는 Line으로 표시
const barKeys = yKeys.slice(0, 1);
const lineKeys = yKeys.slice(1);
return (
<div className="w-full h-full p-2">
{title && (
<div className="text-center text-sm font-semibold text-gray-700 mb-2">
{title}
</div>
)}
<ResponsiveContainer width="100%" height="100%">
<ComposedChart
data={data}
margin={{
top: 5,
right: 30,
left: 20,
bottom: 5,
}}
>
<CartesianGrid strokeDasharray="3 3" stroke="#f0f0f0" />
<XAxis
dataKey={xAxis}
tick={{ fontSize: 12 }}
stroke="#666"
/>
<YAxis
tick={{ fontSize: 12 }}
stroke="#666"
/>
<Tooltip
contentStyle={{
backgroundColor: 'white',
border: '1px solid #ccc',
borderRadius: '4px',
fontSize: '12px'
}}
formatter={(value: any, name: string) => [
typeof value === 'number' ? value.toLocaleString() : value,
name
]}
/>
{showLegend && yKeys.length > 1 && (
<Legend
wrapperStyle={{ fontSize: '12px' }}
/>
)}
{/* 바 차트 */}
{barKeys.map((key, index) => (
<Bar
key={key}
dataKey={key}
fill={colors[index % colors.length]}
radius={[2, 2, 0, 0]}
/>
))}
{/* 라인 차트 */}
{lineKeys.map((key, index) => (
<Line
key={key}
type="monotone"
dataKey={key}
stroke={colors[(barKeys.length + index) % colors.length]}
strokeWidth={2}
dot={{ r: 3 }}
/>
))}
</ComposedChart>
</ResponsiveContainer>
</div>
);
}

109
frontend/components/admin/dashboard/charts/DonutChartComponent.tsx Normal file
View File

@ -0,0 +1,109 @@
'use client';
import React from 'react';
import {
PieChart,
Pie,
Cell,
Tooltip,
Legend,
ResponsiveContainer
} from 'recharts';
import { ChartConfig } from '../types';
interface DonutChartComponentProps {
data: any[];
config: ChartConfig;
width?: number;
height?: number;
}
/**
* 도넛 차트 컴포넌트
* - Recharts PieChart (innerRadius 사용) 사용
* - 비율 표시에 적합 (중앙 공간 활용 가능)
*/
export function DonutChartComponent({ data, config, width = 250, height = 200 }: DonutChartComponentProps) {
const {
xAxis = 'x',
yAxis = 'y',
colors = ['#3B82F6', '#EF4444', '#10B981', '#F59E0B', '#8B5CF6', '#EC4899'],
title,
showLegend = true
} = config;
// 파이 차트용 데이터 변환
const pieData = data.map(item => ({
name: String(item[xAxis] || ''),
value: typeof item[yAxis as string] === 'number' ? item[yAxis as string] : 0
}));
// 총합 계산
const total = pieData.reduce((sum, item) => sum + item.value, 0);
// 커스텀 라벨 (퍼센트 표시)
const renderLabel = (entry: any) => {
const percent = ((entry.value / total) * 100).toFixed(1);
return `${percent}%`;
};
return (
<div className="w-full h-full p-2 flex flex-col">
{title && (
<div className="text-center text-sm font-semibold text-gray-700 mb-2">
{title}
</div>
)}
<ResponsiveContainer width="100%" height="100%">
<PieChart>
<Pie
data={pieData}
cx="50%"
cy="50%"
labelLine={false}
label={renderLabel}
outerRadius={80}
innerRadius={50}
fill="#8884d8"
dataKey="value"
>
{pieData.map((entry, index) => (
<Cell key={`cell-${index}`} fill={colors[index % colors.length]} />
))}
</Pie>
<Tooltip
contentStyle={{
backgroundColor: 'white',
border: '1px solid #ccc',
borderRadius: '4px',
fontSize: '12px'
}}
formatter={(value: any) => [
typeof value === 'number' ? value.toLocaleString() : value,
'값'
]}
/>
{showLegend && (
<Legend
wrapperStyle={{ fontSize: '12px' }}
layout="vertical"
align="right"
verticalAlign="middle"
/>
)}
</PieChart>
</ResponsiveContainer>
{/* 중앙 총합 표시 */}
<div className="absolute top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2 pointer-events-none">
<div className="text-center">
<div className="text-xs text-gray-500">Total</div>
<div className="text-sm font-bold text-gray-800">
{total.toLocaleString()}
</div>
</div>
</div>
</div>
);
}

104
frontend/components/admin/dashboard/charts/LineChartComponent.tsx Normal file
View File

@ -0,0 +1,104 @@
'use client';
import React from 'react';
import {
LineChart,
Line,
XAxis,
YAxis,
CartesianGrid,
Tooltip,
Legend,
ResponsiveContainer
} from 'recharts';
import { ChartConfig } from '../types';
interface LineChartComponentProps {
data: any[];
config: ChartConfig;
width?: number;
height?: number;
}
/**
* 꺾은선 차트 컴포넌트
* - Recharts LineChart 사용
* - 다중 라인 지원
*/
export function LineChartComponent({ data, config, width = 250, height = 200 }: LineChartComponentProps) {
const {
xAxis = 'x',
yAxis = 'y',
colors = ['#3B82F6', '#EF4444', '#10B981', '#F59E0B'],
title,
showLegend = true
} = config;
// Y축 필드들 (단일 또는 다중)
const yFields = Array.isArray(yAxis) ? yAxis : [yAxis];
// 사용할 Y축 키들 결정
const yKeys = yFields.filter(field => field && field !== 'y');
return (
<div className="w-full h-full p-2">
{title && (
<div className="text-center text-sm font-semibold text-gray-700 mb-2">
{title}
</div>
)}
<ResponsiveContainer width="100%" height="100%">
<LineChart
data={data}
margin={{
top: 5,
right: 30,
left: 20,
bottom: 5,
}}
>
<CartesianGrid strokeDasharray="3 3" stroke="#f0f0f0" />
<XAxis
dataKey={xAxis}
tick={{ fontSize: 12 }}
stroke="#666"
/>
<YAxis
tick={{ fontSize: 12 }}
stroke="#666"
/>
<Tooltip
contentStyle={{
backgroundColor: 'white',
border: '1px solid #ccc',
borderRadius: '4px',
fontSize: '12px'
}}
formatter={(value: any, name: string) => [
typeof value === 'number' ? value.toLocaleString() : value,
name
]}
/>
{showLegend && yKeys.length > 1 && (
<Legend
wrapperStyle={{ fontSize: '12px' }}
/>
)}
{yKeys.map((key, index) => (
<Line
key={key}
type="monotone"
dataKey={key}
stroke={colors[index % colors.length]}
strokeWidth={2}
dot={{ r: 3 }}
activeDot={{ r: 5 }}
/>
))}
</LineChart>
</ResponsiveContainer>
</div>
);
}

96
frontend/components/admin/dashboard/charts/PieChartComponent.tsx Normal file
View File

@ -0,0 +1,96 @@
'use client';
import React from 'react';
import {
PieChart,
Pie,
Cell,
Tooltip,
Legend,
ResponsiveContainer
} from 'recharts';
import { ChartConfig } from '../types';
interface PieChartComponentProps {
data: any[];
config: ChartConfig;
width?: number;
height?: number;
}
/**
* 원형 차트 컴포넌트
* - Recharts PieChart 사용
* - 자동 색상 배치 및 레이블
*/
export function PieChartComponent({ data, config, width = 250, height = 200 }: PieChartComponentProps) {
const {
xAxis = 'x',
yAxis = 'y',
colors = ['#3B82F6', '#EF4444', '#10B981', '#F59E0B', '#8B5CF6', '#EC4899', '#06B6D4', '#84CC16'],
title,
showLegend = true
} = config;
// 파이 차트용 데이터 변환
const pieData = data.map((item, index) => ({
name: String(item[xAxis] || `항목 ${index + 1}`),
value: Number(item[yAxis]) || 0,
color: colors[index % colors.length]
})).filter(item => item.value > 0); // 0보다 큰 값만 표시
// 커스텀 레이블 함수
const renderLabel = (entry: any) => {
const percent = ((entry.value / pieData.reduce((sum, item) => sum + item.value, 0)) * 100).toFixed(1);
return `${percent}%`;
};
return (
<div className="w-full h-full p-2">
{title && (
<div className="text-center text-sm font-semibold text-gray-700 mb-2">
{title}
</div>
)}
<ResponsiveContainer width="100%" height="100%">
<PieChart>
<Pie
data={pieData}
cx="50%"
cy="50%"
labelLine={false}
label={renderLabel}
outerRadius={Math.min(width, height) * 0.3}
fill="#8884d8"
dataKey="value"
>
{pieData.map((entry, index) => (
<Cell key={`cell-${index}`} fill={entry.color} />
))}
</Pie>
<Tooltip
contentStyle={{
backgroundColor: 'white',
border: '1px solid #ccc',
borderRadius: '4px',
fontSize: '12px'
}}
formatter={(value: any, name: string) => [
typeof value === 'number' ? value.toLocaleString() : value,
name
]}
/>
{showLegend && (
<Legend
wrapperStyle={{ fontSize: '12px' }}
iconType="circle"
/>
)}
</PieChart>
</ResponsiveContainer>
</div>
);
}

101
frontend/components/admin/dashboard/charts/StackedBarChartComponent.tsx Normal file
View File

@ -0,0 +1,101 @@
'use client';
import React from 'react';
import {
BarChart,
Bar,
XAxis,
YAxis,
CartesianGrid,
Tooltip,
Legend,
ResponsiveContainer
} from 'recharts';
import { ChartConfig } from '../types';
interface StackedBarChartComponentProps {
data: any[];
config: ChartConfig;
width?: number;
height?: number;
}
/**
* 누적 바 차트 컴포넌트
* - Recharts BarChart (stacked) 사용
* - 전체 대비 비율 파악에 적합
* - 다중 시리즈를 누적으로 표시
*/
export function StackedBarChartComponent({ data, config, width = 250, height = 200 }: StackedBarChartComponentProps) {
const {
xAxis = 'x',
yAxis = 'y',
colors = ['#3B82F6', '#EF4444', '#10B981', '#F59E0B'],
title,
showLegend = true
} = config;
// Y축 필드들 (단일 또는 다중)
const yFields = Array.isArray(yAxis) ? yAxis : [yAxis];
const yKeys = yFields.filter(field => field && field !== 'y');
return (
<div className="w-full h-full p-2">
{title && (
<div className="text-center text-sm font-semibold text-gray-700 mb-2">
{title}
</div>
)}
<ResponsiveContainer width="100%" height="100%">
<BarChart
data={data}
margin={{
top: 5,
right: 30,
left: 20,
bottom: 5,
}}
>
<CartesianGrid strokeDasharray="3 3" stroke="#f0f0f0" />
<XAxis
dataKey={xAxis}
tick={{ fontSize: 12 }}
stroke="#666"
/>
<YAxis
tick={{ fontSize: 12 }}
stroke="#666"
/>
<Tooltip
contentStyle={{
backgroundColor: 'white',
border: '1px solid #ccc',
borderRadius: '4px',
fontSize: '12px'
}}
formatter={(value: any, name: string) => [
typeof value === 'number' ? value.toLocaleString() : value,
name
]}
/>
{showLegend && yKeys.length > 1 && (
<Legend
wrapperStyle={{ fontSize: '12px' }}
/>
)}
{yKeys.map((key, index) => (
<Bar
key={key}
dataKey={key}
stackId="a"
fill={colors[index % colors.length]}
radius={index === yKeys.length - 1 ? [2, 2, 0, 0] : [0, 0, 0, 0]}
/>
))}
</BarChart>
</ResponsiveContainer>
</div>
);
}

12
frontend/components/admin/dashboard/charts/index.ts Normal file
View File

@ -0,0 +1,12 @@
/**
* 차트 컴포넌트 인덱스
*/
export { ChartRenderer } from './ChartRenderer';
export { BarChartComponent } from './BarChartComponent';
export { PieChartComponent } from './PieChartComponent';
export { LineChartComponent } from './LineChartComponent';
export { AreaChartComponent } from './AreaChartComponent';
export { StackedBarChartComponent } from './StackedBarChartComponent';
export { DonutChartComponent } from './DonutChartComponent';
export { ComboChartComponent } from './ComboChartComponent';

13
frontend/components/admin/dashboard/index.ts Normal file
View File

@ -0,0 +1,13 @@
/**
* 대시보드 관리 컴포넌트 인덱스
*/
export { default as DashboardDesigner } from './DashboardDesigner';
export { DashboardCanvas } from './DashboardCanvas';
export { DashboardSidebar } from './DashboardSidebar';
export { DashboardToolbar } from './DashboardToolbar';
export { CanvasElement } from './CanvasElement';
export { QueryEditor } from './QueryEditor';
export { ChartConfigPanel } from './ChartConfigPanel';
export { ElementConfigModal } from './ElementConfigModal';
export * from './types';

68
frontend/components/admin/dashboard/types.ts Normal file
View File

@ -0,0 +1,68 @@
/**
* 대시보드 관리 시스템 타입 정의
*/
export type ElementType = 'chart' | 'widget';
export type ElementSubtype =
| 'bar' | 'pie' | 'line' | 'area' | 'stacked-bar' | 'donut' | 'combo' // 차트 타입
| 'exchange' | 'weather'; // 위젯 타입
export interface Position {
x: number;
y: number;
}
export interface Size {
width: number;
height: number;
}
export interface DashboardElement {
id: string;
type: ElementType;
subtype: ElementSubtype;
position: Position;
size: Size;
title: string;
content: string;
dataSource?: ChartDataSource; // 데이터 소스 설정
chartConfig?: ChartConfig; // 차트 설정
}
export interface DragData {
type: ElementType;
subtype: ElementSubtype;
}
export interface ResizeHandle {
direction: 'nw' | 'ne' | 'sw' | 'se';
cursor: string;
}
export interface ChartDataSource {
type: 'api' | 'database' | 'static';
endpoint?: string; // API 엔드포인트
query?: string; // SQL 쿼리
refreshInterval?: number; // 자동 새로고침 간격 (ms)
filters?: any[]; // 필터 조건
lastExecuted?: string; // 마지막 실행 시간
}
export interface ChartConfig {
xAxis?: string; // X축 데이터 필드
yAxis?: string | string[]; // Y축 데이터 필드 (단일 또는 다중)
groupBy?: string; // 그룹핑 필드
aggregation?: 'sum' | 'avg' | 'count' | 'max' | 'min';
colors?: string[]; // 차트 색상
title?: string; // 차트 제목
showLegend?: boolean; // 범례 표시 여부
}
export interface QueryResult {
columns: string[]; // 컬럼명 배열
rows: Record<string, any>[]; // 데이터 행 배열
totalRows: number; // 전체 행 수
executionTime: number; // 실행 시간 (ms)
error?: string; // 오류 메시지
}

277
frontend/components/dashboard/DashboardViewer.tsx Normal file
View File

@ -0,0 +1,277 @@
'use client';
import React, { useState, useEffect, useCallback } from 'react';
import { DashboardElement, QueryResult } from '@/components/admin/dashboard/types';
import { ChartRenderer } from '@/components/admin/dashboard/charts/ChartRenderer';
interface DashboardViewerProps {
elements: DashboardElement[];
dashboardId: string;
refreshInterval?: number; // 전체 대시보드 새로고침 간격 (ms)
}
/**
* 대시보드 뷰어 컴포넌트
* - 저장된 대시보드를 읽기 전용으로 표시
* - 실시간 데이터 업데이트
* - 반응형 레이아웃
*/
export function DashboardViewer({ elements, dashboardId, refreshInterval }: DashboardViewerProps) {
const [elementData, setElementData] = useState<Record<string, QueryResult>>({});
const [loadingElements, setLoadingElements] = useState<Set<string>>(new Set());
const [lastRefresh, setLastRefresh] = useState<Date>(new Date());
// 개별 요소 데이터 로딩
const loadElementData = useCallback(async (element: DashboardElement) => {
if (!element.dataSource?.query || element.type !== 'chart') {
return;
}
setLoadingElements(prev => new Set([...prev, element.id]));
try {
// console.log(`🔄 요소 ${element.id} 데이터 로딩 시작:`, element.dataSource.query);
// 실제 API 호출
const { dashboardApi } = await import('@/lib/api/dashboard');
const result = await dashboardApi.executeQuery(element.dataSource.query);
// console.log(`✅ 요소 ${element.id} 데이터 로딩 완료:`, result);
const data: QueryResult = {
columns: result.columns || [],
rows: result.rows || [],
totalRows: result.rowCount || 0,
executionTime: 0
};
setElementData(prev => ({
...prev,
[element.id]: data
}));
} catch (error) {
// console.error(`❌ Element ${element.id} data loading error:`, error);
} finally {
setLoadingElements(prev => {
const newSet = new Set(prev);
newSet.delete(element.id);
return newSet;
});
}
}, []);
// 모든 요소 데이터 로딩
const loadAllData = useCallback(async () => {
setLastRefresh(new Date());
const chartElements = elements.filter(el => el.type === 'chart' && el.dataSource?.query);
// 병렬로 모든 차트 데이터 로딩
await Promise.all(chartElements.map(element => loadElementData(element)));
}, [elements, loadElementData]);
// 초기 데이터 로딩
useEffect(() => {
loadAllData();
}, [loadAllData]);
// 전체 새로고침 간격 설정
useEffect(() => {
if (!refreshInterval || refreshInterval === 0) {
return;
}
const interval = setInterval(loadAllData, refreshInterval);
return () => clearInterval(interval);
}, [refreshInterval, loadAllData]);
// 요소가 없는 경우
if (elements.length === 0) {
return (
<div className="h-full flex items-center justify-center bg-gray-50">
<div className="text-center">
<div className="text-6xl mb-4">📊</div>
<div className="text-xl font-medium text-gray-700 mb-2">
표시할 요소가 없습니다
</div>
<div className="text-sm text-gray-500">
대시보드 편집기에서 차트나 위젯을 추가해보세요
</div>
</div>
</div>
);
}
return (
<div className="relative w-full h-full bg-gray-100 overflow-auto">
{/* 새로고침 상태 표시 */}
<div className="absolute top-4 right-4 z-10 bg-white rounded-lg shadow-sm px-3 py-2 text-xs text-gray-600">
마지막 업데이트: {lastRefresh.toLocaleTimeString()}
{Array.from(loadingElements).length > 0 && (
<span className="ml-2 text-blue-600">
({Array.from(loadingElements).length}개 로딩 중...)
</span>
)}
</div>
{/* 대시보드 요소들 */}
<div className="relative" style={{ minHeight: '100%' }}>
{elements.map((element) => (
<ViewerElement
key={element.id}
element={element}
data={elementData[element.id]}
isLoading={loadingElements.has(element.id)}
onRefresh={() => loadElementData(element)}
/>
))}
</div>
</div>
);
}
interface ViewerElementProps {
element: DashboardElement;
data?: QueryResult;
isLoading: boolean;
onRefresh: () => void;
}
/**
* 개별 뷰어 요소 컴포넌트
*/
function ViewerElement({ element, data, isLoading, onRefresh }: ViewerElementProps) {
const [isHovered, setIsHovered] = useState(false);
return (
<div
className="absolute bg-white rounded-lg shadow-sm border border-gray-200 overflow-hidden"
style={{
left: element.position.x,
top: element.position.y,
width: element.size.width,
height: element.size.height
}}
onMouseEnter={() => setIsHovered(true)}
onMouseLeave={() => setIsHovered(false)}
>
{/* 헤더 */}
<div className="bg-gray-50 px-4 py-3 border-b border-gray-200 flex justify-between items-center">
<h3 className="font-semibold text-gray-800 text-sm">{element.title}</h3>
{/* 새로고침 버튼 (호버 시에만 표시) */}
{isHovered && (
<button
onClick={onRefresh}
disabled={isLoading}
className="text-gray-400 hover:text-gray-600 disabled:opacity-50"
title="새로고침"
>
{isLoading ? (
<div className="w-4 h-4 border border-gray-400 border-t-transparent rounded-full animate-spin" />
) : (
'🔄'
)}
</button>
)}
</div>
{/* 내용 */}
<div className="h-[calc(100%-57px)]">
{element.type === 'chart' ? (
<ChartRenderer
element={element}
data={data}
width={element.size.width}
height={element.size.height - 57}
/>
) : (
// 위젯 렌더링
<div className="w-full h-full p-4 flex items-center justify-center bg-gradient-to-br from-blue-400 to-purple-600 text-white">
<div className="text-center">
<div className="text-3xl mb-2">
{element.subtype === 'exchange' && '💱'}
{element.subtype === 'weather' && '☁️'}
</div>
<div className="text-sm whitespace-pre-line">{element.content}</div>
</div>
</div>
)}
</div>
{/* 로딩 오버레이 */}
{isLoading && (
<div className="absolute inset-0 bg-white bg-opacity-75 flex items-center justify-center">
<div className="text-center">
<div className="w-6 h-6 border-2 border-blue-500 border-t-transparent rounded-full animate-spin mx-auto mb-2" />
<div className="text-sm text-gray-600">업데이트 중...</div>
</div>
</div>
)}
</div>
);
}
/**
* 샘플 쿼리 결과 생성 함수 (뷰어용)
*/
function generateSampleQueryResult(query: string, chartType: string): QueryResult {
// 시간에 따라 약간씩 다른 데이터 생성 (실시간 업데이트 시뮬레이션)
const timeVariation = Math.sin(Date.now() / 10000) * 0.1 + 1;
const isMonthly = query.toLowerCase().includes('month');
const isSales = query.toLowerCase().includes('sales') || query.toLowerCase().includes('매출');
const isUsers = query.toLowerCase().includes('users') || query.toLowerCase().includes('사용자');
const isProducts = query.toLowerCase().includes('product') || query.toLowerCase().includes('상품');
const isWeekly = query.toLowerCase().includes('week');
let columns: string[];
let rows: Record<string, any>[];
if (isMonthly && isSales) {
columns = ['month', 'sales', 'order_count'];
rows = [
{ month: '2024-01', sales: Math.round(1200000 * timeVariation), order_count: Math.round(45 * timeVariation) },
{ month: '2024-02', sales: Math.round(1350000 * timeVariation), order_count: Math.round(52 * timeVariation) },
{ month: '2024-03', sales: Math.round(1180000 * timeVariation), order_count: Math.round(41 * timeVariation) },
{ month: '2024-04', sales: Math.round(1420000 * timeVariation), order_count: Math.round(58 * timeVariation) },
{ month: '2024-05', sales: Math.round(1680000 * timeVariation), order_count: Math.round(67 * timeVariation) },
{ month: '2024-06', sales: Math.round(1540000 * timeVariation), order_count: Math.round(61 * timeVariation) },
];
} else if (isWeekly && isUsers) {
columns = ['week', 'new_users'];
rows = [
{ week: '2024-W10', new_users: Math.round(23 * timeVariation) },
{ week: '2024-W11', new_users: Math.round(31 * timeVariation) },
{ week: '2024-W12', new_users: Math.round(28 * timeVariation) },
{ week: '2024-W13', new_users: Math.round(35 * timeVariation) },
{ week: '2024-W14', new_users: Math.round(42 * timeVariation) },
{ week: '2024-W15', new_users: Math.round(38 * timeVariation) },
];
} else if (isProducts) {
columns = ['product_name', 'total_sold', 'revenue'];
rows = [
{ product_name: '스마트폰', total_sold: Math.round(156 * timeVariation), revenue: Math.round(234000000 * timeVariation) },
{ product_name: '노트북', total_sold: Math.round(89 * timeVariation), revenue: Math.round(178000000 * timeVariation) },
{ product_name: '태블릿', total_sold: Math.round(134 * timeVariation), revenue: Math.round(67000000 * timeVariation) },
{ product_name: '이어폰', total_sold: Math.round(267 * timeVariation), revenue: Math.round(26700000 * timeVariation) },
{ product_name: '스마트워치', total_sold: Math.round(98 * timeVariation), revenue: Math.round(49000000 * timeVariation) },
];
} else {
columns = ['category', 'value', 'count'];
rows = [
{ category: 'A', value: Math.round(100 * timeVariation), count: Math.round(10 * timeVariation) },
{ category: 'B', value: Math.round(150 * timeVariation), count: Math.round(15 * timeVariation) },
{ category: 'C', value: Math.round(120 * timeVariation), count: Math.round(12 * timeVariation) },
{ category: 'D', value: Math.round(180 * timeVariation), count: Math.round(18 * timeVariation) },
{ category: 'E', value: Math.round(90 * timeVariation), count: Math.round(9 * timeVariation) },
];
}
return {
columns,
rows,
totalRows: rows.length,
executionTime: Math.floor(Math.random() * 100) + 50,
};
}

136
frontend/components/dataflow/connection/redesigned/RightPanel/ActionConfig/ActionConditionBuilder.tsx
View File

@ -268,17 +268,19 @@ const ActionConditionBuilder: React.FC<ActionConditionBuilderProps> = ({
{fromColumns.length > 0 && (
<>
<div className="text-muted-foreground px-2 py-1 text-xs font-medium">FROM 테이블</div>
{fromColumns.map((column) => (
<SelectItem key={`from_${column.columnName}`} value={`from.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-blue-600">📤</span>
<span>{column.displayName || column.columnName}</span>
<Badge variant="outline" className="text-xs">
{column.webType || column.dataType}
</Badge>
</div>
</SelectItem>
))}
{fromColumns
.filter((column) => column.columnName) // 빈 문자열 제외
.map((column) => (
<SelectItem key={`from_${column.columnName}`} value={`from.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-blue-600">📤</span>
<span>{column.displayName || column.columnName}</span>
<Badge variant="outline" className="text-xs">
{column.webType || column.dataType}
</Badge>
</div>
</SelectItem>
))}
</>
)}
@ -286,15 +288,17 @@ const ActionConditionBuilder: React.FC<ActionConditionBuilderProps> = ({
{toColumns.length > 0 && (
<>
<div className="text-muted-foreground px-2 py-1 text-xs font-medium">TO 테이블</div>
{toColumns.map((column) => (
<SelectItem key={`to_${column.columnName}`} value={`to.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-green-600">📥</span>
<span>{column.displayName || column.columnName}</span>
<Badge variant="outline" className="text-xs">
{column.webType || column.dataType}
</Badge>
</div>
{toColumns
.filter((column) => column.columnName) // 빈 문자열 제외
.map((column) => (
<SelectItem key={`to_${column.columnName}`} value={`to.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-green-600">📥</span>
<span>{column.displayName || column.columnName}</span>
<Badge variant="outline" className="text-xs">
{column.webType || column.dataType}
</Badge>
</div>
</SelectItem>
))}
</>
@ -488,14 +492,16 @@ const ActionConditionBuilder: React.FC<ActionConditionBuilderProps> = ({
{fromColumns.length > 0 && (
<>
<div className="text-muted-foreground px-2 py-1 text-xs font-medium">FROM 테이블</div>
{fromColumns.map((column) => (
<SelectItem key={`from_${column.columnName}`} value={`from.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-blue-600">📤</span>
<span>{column.displayName || column.columnName}</span>
</div>
</SelectItem>
))}
{fromColumns
.filter((column) => column.columnName) // 빈 문자열 제외
.map((column) => (
<SelectItem key={`from_${column.columnName}`} value={`from.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-blue-600">📤</span>
<span>{column.displayName || column.columnName}</span>
</div>
</SelectItem>
))}
</>
)}
@ -503,14 +509,16 @@ const ActionConditionBuilder: React.FC<ActionConditionBuilderProps> = ({
{toColumns.length > 0 && (
<>
<div className="text-muted-foreground px-2 py-1 text-xs font-medium">TO 테이블</div>
{toColumns.map((column) => (
<SelectItem key={`to_${column.columnName}`} value={`to.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-green-600">📥</span>
<span>{column.displayName || column.columnName}</span>
</div>
</SelectItem>
))}
{toColumns
.filter((column) => column.columnName) // 빈 문자열 제외
.map((column) => (
<SelectItem key={`to_${column.columnName}`} value={`to.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-green-600">📥</span>
<span>{column.displayName || column.columnName}</span>
</div>
</SelectItem>
))}
</>
)}
</SelectContent>
@ -612,14 +620,16 @@ const ActionConditionBuilder: React.FC<ActionConditionBuilderProps> = ({
<div className="text-muted-foreground px-2 py-1 text-xs font-medium">
FROM 테이블
</div>
{fromColumns.map((column) => (
<SelectItem key={`from_${column.columnName}`} value={`from.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-blue-600">📤</span>
<span>{column.displayName || column.columnName}</span>
</div>
</SelectItem>
))}
{fromColumns
.filter((column) => column.columnName) // 빈 문자열 제외
.map((column) => (
<SelectItem key={`from_${column.columnName}`} value={`from.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-blue-600">📤</span>
<span>{column.displayName || column.columnName}</span>
</div>
</SelectItem>
))}
</>
)}
@ -627,13 +637,15 @@ const ActionConditionBuilder: React.FC<ActionConditionBuilderProps> = ({
{toColumns.length > 0 && (
<>
<div className="text-muted-foreground px-2 py-1 text-xs font-medium">TO 테이블</div>
{toColumns.map((column) => (
<SelectItem key={`to_${column.columnName}`} value={`to.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-green-600">📥</span>
<span>{column.displayName || column.columnName}</span>
</div>
</SelectItem>
{toColumns
.filter((column) => column.columnName) // 빈 문자열 제외
.map((column) => (
<SelectItem key={`to_${column.columnName}`} value={`to.${column.columnName}`}>
<div className="flex items-center gap-2">
<span className="text-green-600">📥</span>
<span>{column.displayName || column.columnName}</span>
</div>
</SelectItem>
))}
</>
)}
@ -729,16 +741,18 @@ const ActionConditionBuilder: React.FC<ActionConditionBuilderProps> = ({
<SelectValue placeholder="대상 필드" />
</SelectTrigger>
<SelectContent>
{getAvailableFieldsForMapping(index).map((column) => (
<SelectItem key={column.columnName} value={column.columnName}>
<div className="flex items-center gap-2">
<span>{column.displayName || column.columnName}</span>
<Badge variant="outline" className="text-xs">
{column.webType || column.dataType}
</Badge>
</div>
</SelectItem>
))}
{getAvailableFieldsForMapping(index)
.filter((column) => column.columnName) // 빈 문자열 제외
.map((column) => (
<SelectItem key={column.columnName} value={column.columnName}>
<div className="flex items-center gap-2">
<span>{column.displayName || column.columnName}</span>
<Badge variant="outline" className="text-xs">
{column.webType || column.dataType}
</Badge>
</div>
</SelectItem>
))}
</SelectContent>
</Select>

1
frontend/components/dataflow/connection/redesigned/RightPanel/ControlConditionStep.tsx
View File

@ -233,6 +233,7 @@ const ControlConditionStep: React.FC<ControlConditionStepProps> = ({ state, acti
{[...fromColumns, ...toColumns]
.filter(
(col, index, array) =>
col.columnName && // 빈 문자열 제외
array.findIndex((c) => c.columnName === col.columnName) === index,
)
.map((col) => (

19
frontend/components/screen/EditModal.tsx
View File

@ -51,7 +51,7 @@ export const EditModal: React.FC<EditModalProps> = ({
console.log(`🎯 계산된 모달 크기: ${maxWidth}px x ${maxHeight}px`);
console.log(
`📍 컴포넌트 위치들:`,
"📍 컴포넌트 위치들:",
components.map((c) => ({ x: c.position?.x, y: c.position?.y, w: c.size?.width, h: c.size?.height })),
);
return { width: maxWidth, height: maxHeight };
@ -85,7 +85,7 @@ export const EditModal: React.FC<EditModalProps> = ({
// 스크롤 완전 제거
if (modalContent) {
modalContent.style.overflow = "hidden";
console.log(`🚫 스크롤 완전 비활성화`);
console.log("🚫 스크롤 완전 비활성화");
}
}, 100); // 100ms 지연으로 렌더링 완료 후 실행
}
@ -152,7 +152,7 @@ export const EditModal: React.FC<EditModalProps> = ({
// 코드 타입인 경우 특별히 로깅
if ((comp as any).widgetType === "code") {
console.log(` 🔍 코드 타입 세부정보:`, {
console.log(" 🔍 코드 타입 세부정보:", {
columnName: comp.columnName,
componentId: comp.id,
formValue,
@ -243,7 +243,7 @@ export const EditModal: React.FC<EditModalProps> = ({
minHeight: dynamicSize.height,
maxWidth: "95vw",
maxHeight: "95vh",
zIndex: 1000, // 모든 컴포넌트보다 위에 표시
zIndex: 9999, // 모든 컴포넌트보다 위에 표시
}}
data-radix-portal="true"
>
@ -251,7 +251,7 @@ export const EditModal: React.FC<EditModalProps> = ({
<DialogTitle>수정</DialogTitle>
</DialogHeader>
<div className="flex-1 overflow-y-auto">
<div className="flex-1 overflow-hidden">
{loading ? (
<div className="flex h-full items-center justify-center">
<div className="text-center">
@ -275,22 +275,21 @@ export const EditModal: React.FC<EditModalProps> = ({
{components.map((component, index) => (
<div
key={component.id}
className="rounded-xl border border-gray-200/60 bg-gradient-to-br from-white to-gray-50/30 p-4 shadow-sm transition-all duration-200 hover:shadow-md"
style={{
position: "absolute",
top: component.position?.y || 0,
left: component.position?.x || 0,
width: component.size?.width || 200,
height: component.size?.height || 40,
zIndex: component.position?.z || (10 + index), // 모달 내부에서 적절한 z-index
zIndex: component.position?.z || 1000 + index, // 모달 내부에서 충분히 높은 z-index
}}
>
{/* 위젯 컴포넌트는 InteractiveScreenViewer 사용 (라벨 표시를 위해) */}
{/* 위젯 컴포넌트는 InteractiveScreenViewer 사용 (라벨 표시) */}
{component.type === "widget" ? (
<InteractiveScreenViewer
component={component}
allComponents={components}
hideLabel={true} // 라벨 숨김 (원래 화면과 동일하게)
hideLabel={false} // ✅ 라벨 표시
formData={formData}
onFormDataChange={(fieldName, value) => {
console.log("📝 폼 데이터 변경:", fieldName, value);
@ -314,7 +313,7 @@ export const EditModal: React.FC<EditModalProps> = ({
...component,
style: {
...component.style,
labelDisplay: false, // 라벨 숨김 (원래 화면과 동일하게)
labelDisplay: true, // ✅ 라벨 표시
},
}}
screenId={screenId}

Some files were not shown because too many files have changed in this diff Show More