kjs
/
ERP-node
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ERP-node/제어관리_외부커넥션_통합_개선_계획서.md

1492 lines
43 KiB
Markdown
Raw Blame History

# 🔧 제어관리 외부 커넥션 통합 개선 계획서
## 📋 프로젝트 개요
### 목적
현재 외부 커넥션 관리에서 관리되고 있는 데이터베이스 커넥션 정보를 제어관리의 데이터 저장 액션에서 활용할 수 있도록 통합하여, 사용자가 다양한 외부 데이터베이스에 데이터를 저장할 수 있는 기능을 구현합니다.
### 현재 상황 분석
#### 기존 외부 커넥션 관리
- **테이블**: `external_db_connections`
- **지원 DB**: MySQL, PostgreSQL, Oracle, SQL Server, SQLite, MariaDB
- **관리 기능**: 연결 정보 CRUD, 연결 테스트, 암호화 저장
- **API**: `/api/external-db-connections/*` 엔드포인트
#### 기존 제어관리 시스템
- **연결 종류**: 현재 "데이터 저장" 타입 지원
- **액션 타입**: INSERT, UPDATE, DELETE
- **매핑**: FROM 테이블 → TO 테이블 컬럼 매핑
- **제약**: 현재는 메인 데이터베이스 내에서만 동작
### 변경 요구사항
1. **커넥션 선택 기능 추가**
- INSERT 액션 타입 선택 시 커넥션 선택 단계 추가
- FROM/TO 테이블 각각에 대해 독립적인 커넥션 설정
2. **테이블 선택 기능 개선**
- 선택한 커넥션에 있는 테이블 목록 동적 로딩
- FROM 커넥션의 테이블과 TO 커넥션의 테이블 독립 선택
3. **컬럼 매핑 규칙 유지**
- FROM 테이블의 1개 컬럼 → TO 테이블의 2개 이상 컬럼 매핑 가능
- FROM 테이블의 2개 이상 컬럼 → TO 테이블의 1개 컬럼 매핑 **불가**
- 기존 UI 구조 최대한 유지
## 🏗️ 시스템 아키텍처 설계
### 1. 데이터 구조 확장
#### 기존 DataSaveSettings 구조
```typescript
interface DataSaveSettings {
connectionType: "data-save";
actions: Array<{
actionType: "insert" | "update" | "delete";
targetTable: string;
fieldMappings: FieldMapping[];
}>;
}
```
#### 개선된 DataSaveSettings 구조
```typescript
interface EnhancedDataSaveSettings {
connectionType: "data-save";
actions: Array<{
actionType: "insert" | "update" | "delete";
// 🆕 커넥션 정보 추가
fromConnection?: {
connectionId?: number;
connectionName?: string;
dbType?: string;
};
toConnection?: {
connectionId?: number;
connectionName?: string;
dbType?: string;
};
// 기존 필드들
targetTable: string;
fromTable?: string; // 🆕 명시적으로 추가
fieldMappings: EnhancedFieldMapping[];
}>;
}
interface EnhancedFieldMapping {
sourceTable: string;
sourceField: string;
targetTable: string;
targetField: string;
defaultValue?: string;
transformFunction?: string;
// 🆕 커넥션 정보 추가
sourceConnectionId?: number;
targetConnectionId?: number;
}
```
### 2. UI 컴포넌트 구조 개선
#### 단계별 설정 플로우
```
1. 액션 타입 선택 (INSERT/UPDATE/DELETE)
↓
2. [모든 액션 타입] 커넥션 설정 단계
├─ FROM 커넥션 선택 (데이터 소스)
└─ TO 커넥션 선택 (데이터 대상)
↓
3. 테이블 선택 단계
├─ FROM 테이블 선택 (선택한 FROM 커넥션의 테이블들)
└─ TO 테이블 선택 (선택한 TO 커넥션의 테이블들)
↓
4. 컬럼 매핑 단계 (액션 타입별 UI)
├─ INSERT: InsertFieldMappingPanel
├─ UPDATE: UpdateFieldMappingPanel
└─ DELETE: DeleteConditionPanel
```
#### 새로운 컴포넌트 구조
```typescript
// 1. 커넥션 선택 컴포넌트 (신규)
interface ConnectionSelectionPanelProps {
fromConnectionId?: number;
toConnectionId?: number;
onFromConnectionChange: (connectionId: number) => void;
onToConnectionChange: (connectionId: number) => void;
availableConnections: ExternalDbConnection[];
actionType: "insert" | "update" | "delete";
// 🆕 자기 자신 테이블 작업 지원
allowSameConnection?: boolean;
currentConnectionId?: number; // 현재 메인 DB 커넥션
}
// 2. 테이블 선택 컴포넌트 (확장)
interface TableSelectionPanelProps {
fromConnectionId?: number;
toConnectionId?: number;
selectedFromTable?: string;
selectedToTable?: string;
onFromTableChange: (tableName: string) => void;
onToTableChange: (tableName: string) => void;
actionType: "insert" | "update" | "delete";
// 🆕 자기 자신 테이블 작업 지원
allowSameTable?: boolean;
showSameTableWarning?: boolean;
}
// 3. 액션 타입별 매핑 컴포넌트 (확장)
interface InsertFieldMappingPanelProps {
// INSERT: FROM → TO 매핑
}
interface UpdateFieldMappingPanelProps {
// UPDATE: FROM 조건 + TO 업데이트 필드
fromTableColumns: ColumnInfo[];
toTableColumns: ColumnInfo[];
updateConditions: UpdateCondition[];
updateFields: UpdateFieldMapping[];
onConditionsChange: (conditions: UpdateCondition[]) => void;
onFieldsChange: (fields: UpdateFieldMapping[]) => void;
}
interface DeleteConditionPanelProps {
// DELETE: FROM 조건 + TO 삭제 조건
fromTableColumns: ColumnInfo[];
toTableColumns: ColumnInfo[];
deleteConditions: DeleteCondition[];
onConditionsChange: (conditions: DeleteCondition[]) => void;
}
```
## 🔧 구현 세부 계획
### Phase 1: 백엔드 인프라 구축 (2주)
#### 1.1 외부 커넥션 조회 API 확장
```typescript
// 기존 API 확장
GET / api / external - db - connections / active;
// 응답: 활성화된 모든 커넥션 목록
GET / api / external - db - connections / { connectionId } / tables;
// 응답: 특정 커넥션의 테이블 목록
GET / api / external -
db -
connections / { connectionId } / tables / { tableName } / columns;
// 응답: 특정 테이블의 컬럼 정보
```
#### 1.2 다중 커넥션 쿼리 실행 서비스
```typescript
export class MultiConnectionQueryService {
// 소스 커넥션에서 데이터 조회
async fetchDataFromConnection(
connectionId: number,
tableName: string,
conditions?: Record<string, any>
): Promise<Record<string, any>[]>;
// 대상 커넥션에 데이터 삽입
async insertDataToConnection(
connectionId: number,
tableName: string,
data: Record<string, any>
): Promise<any>;
// 🆕 대상 커넥션에 데이터 업데이트
async updateDataToConnection(
connectionId: number,
tableName: string,
data: Record<string, any>,
conditions: Record<string, any>
): Promise<any>;
// 🆕 대상 커넥션에서 데이터 삭제
async deleteDataFromConnection(
connectionId: number,
tableName: string,
conditions: Record<string, any>
): Promise<any>;
// 커넥션별 테이블 목록 조회
async getTablesFromConnection(connectionId: number): Promise<TableInfo[]>;
// 커넥션별 컬럼 정보 조회
async getColumnsFromConnection(
connectionId: number,
tableName: string
): Promise<ColumnInfo[]>;
// 🆕 자기 자신 테이블 작업 전용 메서드들
async validateSelfTableOperation(
tableName: string,
operation: "update" | "delete",
conditions: any[]
): Promise<ValidationResult>;
// 🆕 메인 DB 작업 (connectionId = 0인 경우)
async executeOnMainDatabase(
operation: "select" | "insert" | "update" | "delete",
tableName: string,
data?: Record<string, any>,
conditions?: Record<string, any>
): Promise<any>;
}
```
#### 1.3 제어관리 서비스 확장
```typescript
export class EnhancedDataflowControlService {
// 기존 메서드 확장
async executeDataflowControl(
diagramId: number,
relationshipId: string,
triggerType: "insert" | "update" | "delete",
sourceData: Record<string, any>,
tableName: string,
// 🆕 추가 매개변수
sourceConnectionId?: number,
targetConnectionId?: number
): Promise<{
success: boolean;
message: string;
executedActions?: any[];
errors?: string[];
}>;
// 🆕 다중 커넥션 INSERT 실행
private async executeMultiConnectionInsert(
action: ControlAction,
sourceData: Record<string, any>,
sourceConnectionId?: number,
targetConnectionId?: number
): Promise<any>;
// 🆕 다중 커넥션 UPDATE 실행
private async executeMultiConnectionUpdate(
action: ControlAction,
sourceData: Record<string, any>,
sourceConnectionId?: number,
targetConnectionId?: number
): Promise<any>;
// 🆕 다중 커넥션 DELETE 실행
private async executeMultiConnectionDelete(
action: ControlAction,
sourceData: Record<string, any>,
sourceConnectionId?: number,
targetConnectionId?: number
): Promise<any>;
}
```
### Phase 2: 프론트엔드 UI 개선 (3주)
#### 2.1 ConnectionSelectionPanel 컴포넌트 개발
```typescript
export const ConnectionSelectionPanel: React.FC<
ConnectionSelectionPanelProps
> = ({
fromConnectionId,
toConnectionId,
onFromConnectionChange,
onToConnectionChange,
availableConnections,
actionType,
}) => {
const getConnectionLabels = () => {
switch (actionType) {
case "insert":
return {
from: {
title: "소스 데이터베이스 연결",
desc: "데이터를 가져올 데이터베이스 연결을 선택하세요",
},
to: {
title: "대상 데이터베이스 연결",
desc: "데이터를 저장할 데이터베이스 연결을 선택하세요",
},
};
case "update":
return {
from: {
title: "조건 확인 데이터베이스",
desc: "업데이트 조건을 확인할 데이터베이스 연결을 선택하세요 (자기 자신 가능)",
},
to: {
title: "업데이트 대상 데이터베이스",
desc: "데이터를 업데이트할 데이터베이스 연결을 선택하세요 (자기 자신 가능)",
},
};
case "delete":
return {
from: {
title: "조건 확인 데이터베이스",
desc: "삭제 조건을 확인할 데이터베이스 연결을 선택하세요 (자기 자신 가능)",
},
to: {
title: "삭제 대상 데이터베이스",
desc: "데이터를 삭제할 데이터베이스 연결을 선택하세요 (자기 자신 가능)",
},
};
}
};
// 🆕 자기 자신 테이블 작업 시 경고 메시지
const getSameConnectionWarning = () => {
if (fromConnectionId === toConnectionId && fromConnectionId) {
switch (actionType) {
case "update":
return "⚠️ 같은 데이터베이스에서 UPDATE 작업을 수행합니다. 조건을 신중히 설정하세요.";
case "delete":
return "🚨 같은 데이터베이스에서 DELETE 작업을 수행합니다. 데이터 손실에 주의하세요.";
}
}
return null;
};
const labels = getConnectionLabels();
const warningMessage = getSameConnectionWarning();
return (
<div className="space-y-4">
<div className="grid grid-cols-2 gap-6">
{/* FROM 커넥션 선택 */}
<Card>
<CardHeader>
<CardTitle>{labels.from.title}</CardTitle>
<CardDescription>{labels.from.desc}</CardDescription>
</CardHeader>
<CardContent>
<Select
value={fromConnectionId?.toString() || ""}
onValueChange={(value) => onFromConnectionChange(parseInt(value))}
>
<SelectTrigger>
<SelectValue placeholder="커넥션을 선택하세요" />
</SelectTrigger>
<SelectContent>
{/* 🆕 현재 메인 DB도 선택 가능 */}
<SelectItem value="0">
<div className="flex items-center gap-2">
<Badge variant="default">현재 DB</Badge>
<span>메인 데이터베이스 (현재 시스템)</span>
</div>
</SelectItem>
{availableConnections.map((conn) => (
<SelectItem key={conn.id} value={conn.id!.toString()}>
<div className="flex items-center gap-2">
<Badge variant="outline">{conn.db_type}</Badge>
<span>{conn.connection_name}</span>
</div>
</SelectItem>
))}
</SelectContent>
</Select>
</CardContent>
</Card>
{/* TO 커넥션 선택 */}
<Card>
<CardHeader>
<CardTitle>{labels.to.title}</CardTitle>
<CardDescription>{labels.to.desc}</CardDescription>
</CardHeader>
<CardContent>
<Select
value={toConnectionId?.toString() || ""}
onValueChange={(value) => onToConnectionChange(parseInt(value))}
>
<SelectTrigger>
<SelectValue placeholder="커넥션을 선택하세요" />
</SelectTrigger>
<SelectContent>
{/* 🆕 현재 메인 DB도 선택 가능 */}
<SelectItem value="0">
<div className="flex items-center gap-2">
<Badge variant="default">현재 DB</Badge>
<span>메인 데이터베이스 (현재 시스템)</span>
</div>
</SelectItem>
{availableConnections.map((conn) => (
<SelectItem key={conn.id} value={conn.id!.toString()}>
<div className="flex items-center gap-2">
<Badge variant="outline">{conn.db_type}</Badge>
<span>{conn.connection_name}</span>
</div>
</SelectItem>
))}
</SelectContent>
</Select>
</CardContent>
</Card>
</div>
{/* 🆕 자기 자신 테이블 작업 시 경고 */}
{warningMessage && (
<Alert variant={actionType === "delete" ? "destructive" : "default"}>
<AlertCircle className="h-4 w-4" />
<AlertTitle>주의사항</AlertTitle>
<AlertDescription>{warningMessage}</AlertDescription>
</Alert>
)}
</div>
);
};
```
#### 2.2 TableSelectionPanel 컴포넌트 확장
```typescript
export const TableSelectionPanel: React.FC<TableSelectionPanelProps> = ({
fromConnectionId,
toConnectionId,
selectedFromTable,
selectedToTable,
onFromTableChange,
onToTableChange,
}) => {
const [fromTables, setFromTables] = useState<TableInfo[]>([]);
const [toTables, setToTables] = useState<TableInfo[]>([]);
const [loading, setLoading] = useState(false);
// 커넥션 변경 시 테이블 목록 로딩
useEffect(() => {
if (fromConnectionId) {
loadTablesFromConnection(fromConnectionId, setFromTables);
}
}, [fromConnectionId]);
useEffect(() => {
if (toConnectionId) {
loadTablesFromConnection(toConnectionId, setToTables);
}
}, [toConnectionId]);
return (
<div className="grid grid-cols-2 gap-6">
{/* FROM 테이블 선택 */}
<TableSelector
title="소스 테이블"
tables={fromTables}
selectedTable={selectedFromTable}
onTableChange={onFromTableChange}
connectionId={fromConnectionId}
disabled={!fromConnectionId}
/>
{/* TO 테이블 선택 */}
<TableSelector
title="대상 테이블"
tables={toTables}
selectedTable={selectedToTable}
onTableChange={onToTableChange}
connectionId={toConnectionId}
disabled={!toConnectionId}
/>
</div>
);
};
```
#### 2.3 InsertFieldMappingPanel 확장
```typescript
// 기존 컴포넌트에 커넥션 정보 추가
interface EnhancedInsertFieldMappingPanelProps
extends InsertFieldMappingPanelProps {
fromConnectionId?: number;
toConnectionId?: number;
fromConnectionName?: string;
toConnectionName?: string;
}
// 컬럼 로딩 로직 수정
useEffect(() => {
if (fromConnectionId && fromTableName) {
loadColumnsFromConnection(fromConnectionId, fromTableName).then(
setFromTableColumns
);
}
}, [fromConnectionId, fromTableName]);
useEffect(() => {
if (toConnectionId && toTableName) {
loadColumnsFromConnection(toConnectionId, toTableName).then(
setToTableColumns
);
}
}, [toConnectionId, toTableName]);
```
### Phase 3: 통합 및 테스트 (1주)
#### 3.1 ActionFieldMappings 컴포넌트 통합
```typescript
export const ActionFieldMappings: React.FC<ActionFieldMappingsProps> = ({
action,
actionIndex,
settings,
onSettingsChange,
// ... 기존 props
}) => {
const renderActionSpecificUI = () => {
// 공통 단계: 커넥션 선택과 테이블 선택
const commonSteps = (
<>
{/* 1단계: 커넥션 선택 */}
<ConnectionSelectionPanel
fromConnectionId={action.fromConnection?.connectionId}
toConnectionId={action.toConnection?.connectionId}
onFromConnectionChange={handleFromConnectionChange}
onToConnectionChange={handleToConnectionChange}
availableConnections={availableConnections}
actionType={action.actionType}
/>
{/* 2단계: 테이블 선택 */}
{hasConnectionsSelected && (
<TableSelectionPanel
fromConnectionId={action.fromConnection?.connectionId}
toConnectionId={action.toConnection?.connectionId}
selectedFromTable={action.fromTable}
selectedToTable={action.targetTable}
onFromTableChange={handleFromTableChange}
onToTableChange={handleToTableChange}
actionType={action.actionType}
/>
)}
</>
);
// 3단계: 액션 타입별 매핑/조건 설정
let specificPanel = null;
if (hasTablesSelected) {
switch (action.actionType) {
case "insert":
specificPanel = (
<InsertFieldMappingPanel
action={action}
actionIndex={actionIndex}
settings={settings}
onSettingsChange={onSettingsChange}
fromTableColumns={fromTableColumns}
toTableColumns={toTableColumns}
fromTableName={action.fromTable}
toTableName={action.targetTable}
fromConnectionId={action.fromConnection?.connectionId}
toConnectionId={action.toConnection?.connectionId}
fromConnectionName={action.fromConnection?.connectionName}
toConnectionName={action.toConnection?.connectionName}
/>
);
break;
case "update":
specificPanel = (
<UpdateFieldMappingPanel
action={action}
actionIndex={actionIndex}
settings={settings}
onSettingsChange={onSettingsChange}
fromTableColumns={fromTableColumns}
toTableColumns={toTableColumns}
fromConnectionId={action.fromConnection?.connectionId}
toConnectionId={action.toConnection?.connectionId}
/>
);
break;
case "delete":
specificPanel = (
<DeleteConditionPanel
action={action}
actionIndex={actionIndex}
settings={settings}
onSettingsChange={onSettingsChange}
fromTableColumns={fromTableColumns}
toTableColumns={toTableColumns}
fromConnectionId={action.fromConnection?.connectionId}
toConnectionId={action.toConnection?.connectionId}
/>
);
break;
}
}
return (
<div className="space-y-6">
{commonSteps}
{specificPanel}
</div>
);
};
return renderActionSpecificUI();
};
```
## 🔄 액션 타입별 상세 구현
### 1. UPDATE 액션 구현
#### UpdateFieldMappingPanel 컴포넌트
```typescript
export const UpdateFieldMappingPanel: React.FC<
UpdateFieldMappingPanelProps
> = ({
action,
actionIndex,
settings,
onSettingsChange,
fromTableColumns,
toTableColumns,
fromConnectionId,
toConnectionId,
}) => {
const [updateConditions, setUpdateConditions] = useState<UpdateCondition[]>(
[]
);
const [updateFields, setUpdateFields] = useState<UpdateFieldMapping[]>([]);
return (
<div className="space-y-6">
{/* UPDATE 조건 설정 */}
<Card>
<CardHeader>
<CardTitle>🔍 업데이트 조건 설정</CardTitle>
<CardDescription>
FROM 테이블에서 어떤 조건을 만족하는 데이터가 있을 때 TO 테이블을
업데이트할지 설정하세요
</CardDescription>
</CardHeader>
<CardContent>
<UpdateConditionBuilder
fromTableColumns={fromTableColumns}
conditions={updateConditions}
onConditionsChange={setUpdateConditions}
/>
</CardContent>
</Card>
{/* UPDATE 필드 매핑 */}
<Card>
<CardHeader>
<CardTitle>📝 업데이트 필드 매핑</CardTitle>
<CardDescription>
FROM 테이블의 값을 TO 테이블의 어떤 필드에 업데이트할지 설정하세요
</CardDescription>
</CardHeader>
<CardContent>
<UpdateFieldMapper
fromTableColumns={fromTableColumns}
toTableColumns={toTableColumns}
fieldMappings={updateFields}
onFieldMappingsChange={setUpdateFields}
/>
</CardContent>
</Card>
{/* WHERE 조건 설정 */}
<Card>
<CardHeader>
<CardTitle>🎯 업데이트 대상 조건</CardTitle>
<CardDescription>
TO 테이블에서 어떤 레코드를 업데이트할지 WHERE 조건을 설정하세요
</CardDescription>
</CardHeader>
<CardContent>
<WhereConditionBuilder
toTableColumns={toTableColumns}
fromTableColumns={fromTableColumns}
onConditionsChange={handleWhereConditionsChange}
/>
</CardContent>
</Card>
</div>
);
};
```
#### UPDATE 데이터 타입 정의
```typescript
interface UpdateCondition {
id: string;
fromColumn: string;
operator: "=" | "!=" | ">" | "<" | ">=" | "<=" | "LIKE" | "IN" | "NOT IN";
value: string | string[];
logicalOperator?: "AND" | "OR";
}
interface UpdateFieldMapping {
id: string;
fromColumn: string;
toColumn: string;
transformFunction?: string;
defaultValue?: string;
}
interface WhereCondition {
id: string;
toColumn: string;
operator: "=" | "!=" | ">" | "<" | ">=" | "<=" | "LIKE" | "IN" | "NOT IN";
valueSource: "from_column" | "static" | "current_timestamp";
fromColumn?: string; // valueSource가 "from_column"인 경우
staticValue?: string; // valueSource가 "static"인 경우
logicalOperator?: "AND" | "OR";
}
```
### 2. DELETE 액션 구현
#### DeleteConditionPanel 컴포넌트
```typescript
export const DeleteConditionPanel: React.FC<DeleteConditionPanelProps> = ({
action,
actionIndex,
settings,
onSettingsChange,
fromTableColumns,
toTableColumns,
fromConnectionId,
toConnectionId,
}) => {
const [deleteConditions, setDeleteConditions] = useState<DeleteCondition[]>(
[]
);
const [whereConditions, setWhereConditions] = useState<WhereCondition[]>([]);
return (
<div className="space-y-6">
{/* DELETE 트리거 조건 설정 */}
<Card>
<CardHeader>
<CardTitle>🔥 삭제 트리거 조건</CardTitle>
<CardDescription>
FROM 테이블에서 어떤 조건을 만족하는 데이터가 있을 때 TO 테이블에서
삭제를 실행할지 설정하세요
</CardDescription>
</CardHeader>
<CardContent>
<DeleteTriggerConditionBuilder
fromTableColumns={fromTableColumns}
conditions={deleteConditions}
onConditionsChange={setDeleteConditions}
/>
</CardContent>
</Card>
{/* DELETE WHERE 조건 설정 */}
<Card>
<CardHeader>
<CardTitle>🎯 삭제 대상 조건</CardTitle>
<CardDescription>
TO 테이블에서 어떤 레코드를 삭제할지 WHERE 조건을 설정하세요
</CardDescription>
</CardHeader>
<CardContent>
<DeleteWhereConditionBuilder
toTableColumns={toTableColumns}
fromTableColumns={fromTableColumns}
conditions={whereConditions}
onConditionsChange={setWhereConditions}
/>
</CardContent>
</Card>
{/* 안전장치 설정 */}
<Card>
<CardHeader>
<CardTitle>🛡️ 삭제 안전장치</CardTitle>
<CardDescription>
예상치 못한 대량 삭제를 방지하기 위한 안전장치를 설정하세요
</CardDescription>
</CardHeader>
<CardContent>
<DeleteSafetySettings
maxDeleteCount={action.maxDeleteCount || 100}
requireConfirmation={action.requireConfirmation || true}
onSettingsChange={handleSafetySettingsChange}
/>
</CardContent>
</Card>
</div>
);
};
```
#### DELETE 데이터 타입 정의
```typescript
interface DeleteCondition {
id: string;
fromColumn: string;
operator:
| "="
| "!="
| ">"
| "<"
| ">="
| "<="
| "LIKE"
| "IN"
| "NOT IN"
| "EXISTS"
| "NOT EXISTS";
value: string | string[];
logicalOperator?: "AND" | "OR";
}
interface DeleteWhereCondition {
id: string;
toColumn: string;
operator: "=" | "!=" | ">" | "<" | ">=" | "<=" | "LIKE" | "IN" | "NOT IN";
valueSource: "from_column" | "static" | "condition_result";
fromColumn?: string;
staticValue?: string;
logicalOperator?: "AND" | "OR";
}
interface DeleteSafetySettings {
maxDeleteCount: number;
requireConfirmation: boolean;
dryRunFirst: boolean;
logAllDeletes: boolean;
}
```
## 🔒 매핑 규칙 구현
### 1. INSERT: FROM → TO 컬럼 매핑 제약사항
#### 허용되는 매핑 (기존과 동일)
```typescript
// ✅ 1:1 매핑
FROM.column1 → TO.column1
// ✅ 1:N 매핑 (하나의 FROM 컬럼이 여러 TO 컬럼에 매핑)
FROM.column1 → TO.column1
FROM.column1 → TO.column2
FROM.column1 → TO.column3
```
#### 금지되는 매핑 (신규 검증 로직)
```typescript
// ❌ N:1 매핑 (여러 FROM 컬럼이 하나의 TO 컬럼에 매핑)
FROM.column1 → TO.column1
FROM.column2 → TO.column1 // 이미 매핑된 TO.column1에 추가 매핑 시도
```
### 2. UPDATE: 조건 및 필드 매핑 제약사항
#### 허용되는 UPDATE 패턴
```typescript
// ✅ 조건부 업데이트
IF (FROM.status = 'completed')
THEN UPDATE TO.table SET status = FROM.new_status WHERE TO.id = FROM.ref_id
// ✅ 다중 필드 업데이트
UPDATE TO.table SET
column1 = FROM.value1,
column2 = FROM.value2,
updated_at = CURRENT_TIMESTAMP
WHERE TO.id = FROM.ref_id
// ✅ 조건부 필드 매핑
IF (FROM.priority > 5) THEN TO.urgent_flag = 'Y'
ELSE TO.urgent_flag = 'N'
```
#### UPDATE 제약사항
```typescript
// ❌ WHERE 조건 없는 전체 테이블 업데이트 (안전장치)
// ❌ PRIMARY KEY 컬럼 업데이트
// ⚠️ 자기 자신 테이블 업데이트 (허용하되 특별한 주의사항)
// 🆕 자기 자신 테이블 UPDATE 시 안전장치
const validateSelfTableUpdate = (
fromTable: string,
toTable: string,
updateConditions: UpdateCondition[],
whereConditions: WhereCondition[]
): ValidationResult => {
if (fromTable === toTable) {
// 1. WHERE 조건 필수
if (!whereConditions.length) {
return {
isValid: false,
error: "자기 자신 테이블 업데이트 시 WHERE 조건이 필수입니다.",
};
}
// 2. 업데이트 조건과 WHERE 조건이 겹치지 않도록 체크
const conditionColumns = updateConditions.map((c) => c.fromColumn);
const whereColumns = whereConditions.map((c) => c.toColumn);
const overlap = conditionColumns.filter((col) =>
whereColumns.includes(col)
);
if (overlap.length > 0) {
return {
isValid: false,
error: `업데이트 조건과 WHERE 조건에서 같은 컬럼(${overlap.join(
", "
)})을 사용하면 예상치 못한 결과가 발생할 수 있습니다.`,
};
}
// 3. 무한 루프 방지 체크
const hasInfiniteLoopRisk = updateConditions.some((condition) =>
whereConditions.some(
(where) =>
where.fromColumn === condition.toColumn &&
where.toColumn === condition.fromColumn
)
);
if (hasInfiniteLoopRisk) {
return {
isValid: false,
error: "자기 참조 업데이트로 인한 무한 루프 위험이 있습니다.",
};
}
}
return { isValid: true };
};
```
### 3. DELETE: 조건 및 안전장치 제약사항
#### 허용되는 DELETE 패턴
```typescript
// ✅ 조건부 삭제
IF (FROM.is_expired = 'Y')
THEN DELETE FROM TO.table WHERE TO.ref_id = FROM.id
// ✅ 관련 데이터 정리
IF (FROM.status = 'cancelled')
THEN DELETE FROM TO.order_items WHERE TO.order_id = FROM.order_id
// ✅ 카스케이드 삭제 시뮬레이션
DELETE FROM TO.child_table WHERE TO.parent_id = FROM.deleted_id
```
#### DELETE 제약사항 및 안전장치
```typescript
// ❌ WHERE 조건 없는 전체 테이블 삭제 (강력한 안전장치)
// ❌ 일정 개수 이상의 대량 삭제 (maxDeleteCount 제한)
// ⚠️ 외래키 제약조건 위반 가능성 체크
// ⚠️ 자기 자신 테이블 삭제 (허용하되 특별한 주의사항)
const validateDeleteSafety = (
fromTable: string,
toTable: string,
deleteConditions: DeleteCondition[],
whereConditions: WhereCondition[],
safetySettings: DeleteSafetySettings
): ValidationResult => {
// 1. WHERE 조건 필수 체크
if (!whereConditions.length) {
return {
isValid: false,
error: "DELETE 작업에는 반드시 WHERE 조건이 필요합니다.",
};
}
// 2. 대량 삭제 제한 체크
if (safetySettings.maxDeleteCount < 1) {
return {
isValid: false,
error: "최대 삭제 개수는 1 이상이어야 합니다.",
};
}
// 🆕 3. 자기 자신 테이블 삭제 시 추가 안전장치
if (fromTable === toTable) {
// 강화된 안전장치: 더 엄격한 제한
const selfDeleteMaxCount = Math.min(safetySettings.maxDeleteCount, 10);
if (safetySettings.maxDeleteCount > selfDeleteMaxCount) {
return {
isValid: false,
error: `자기 자신 테이블 삭제 시 최대 ${selfDeleteMaxCount}개까지만 허용됩니다.`,
};
}
// 삭제 조건이 너무 광범위한지 체크
const hasBroadCondition = deleteConditions.some(
(condition) =>
condition.operator === "!=" ||
condition.operator === "NOT IN" ||
condition.operator === "NOT EXISTS"
);
if (hasBroadCondition) {
return {
isValid: false,
error:
"자기 자신 테이블 삭제 시 부정 조건(!=, NOT IN, NOT EXISTS)은 위험합니다.",
};
}
// WHERE 조건이 충분히 구체적인지 체크
if (whereConditions.length < 2) {
return {
isValid: false,
error:
"자기 자신 테이블 삭제 시 WHERE 조건을 2개 이상 설정하는 것을 권장합니다.",
};
}
}
return { isValid: true };
};
// 🆕 자기 자신 테이블 작업 시 실제 사용 예시
const exampleSelfTableOperations = {
// ✅ 안전한 자기 자신 테이블 UPDATE
safeUpdate: `
UPDATE user_info
SET last_login = NOW(), login_count = login_count + 1
WHERE user_id = 'specific_user' AND status = 'active'
`,
// ✅ 안전한 자기 자신 테이블 DELETE
safeDelete: `
DELETE FROM temp_data
WHERE created_at < NOW() - INTERVAL '7 days'
AND status = 'processed'
AND batch_id = 'specific_batch'
LIMIT 10
`,
// ❌ 위험한 작업들
dangerousOperations: [
"UPDATE table SET column = value (WHERE 조건 없음)",
"DELETE FROM table WHERE status != 'active' (부정 조건으로 예상보다 많이 삭제될 수 있음)",
"UPDATE table SET id = new_id WHERE id = old_id (키 값 변경으로 참조 무결성 위험)",
],
};
```
### 4. 공통 검증 로직
#### 매핑 제약사항 통합 검증
```typescript
const validateMappingConstraints = (
actionType: "insert" | "update" | "delete",
newMapping: ColumnMapping,
existingMappings: ColumnMapping[]
): ValidationResult => {
switch (actionType) {
case "insert":
return validateInsertMapping(newMapping, existingMappings);
case "update":
return validateUpdateMapping(newMapping, existingMappings);
case "delete":
return validateDeleteConditions(newMapping, existingMappings);
}
};
const validateInsertMapping = (
newMapping: ColumnMapping,
existingMappings: ColumnMapping[]
): ValidationResult => {
// TO 컬럼이 이미 다른 FROM 컬럼과 매핑되어 있는지 확인
const existingToMapping = existingMappings.find(
(mapping) => mapping.toColumnName === newMapping.toColumnName
);
if (
existingToMapping &&
existingToMapping.fromColumnName &&
existingToMapping.fromColumnName !== newMapping.fromColumnName
) {
return {
isValid: false,
error: `대상 컬럼 '${newMapping.toColumnName}'은 이미 '${existingToMapping.fromColumnName}'과 매핑되어 있습니다.`,
};
}
return { isValid: true };
};
```
### 2. UI에서의 제약사항 표시
#### 컬럼 선택 시 비활성화 로직
```typescript
const isToColumnClickable = (toColumn: ColumnInfo) => {
const currentMapping = columnMappings.find(
(m) => m.toColumnName === toColumn.columnName
);
// 이미 다른 FROM 컬럼과 매핑된 경우 클릭 불가
if (currentMapping?.fromColumnName) {
return false;
}
// 기본값이 설정된 경우 클릭 불가
if (currentMapping?.defaultValue && currentMapping.defaultValue.trim()) {
return false;
}
// 데이터 타입 호환성 체크
if (!selectedFromColumn) return true;
const fromColumn = fromTableColumns.find(
(col) => col.columnName === selectedFromColumn
);
if (!fromColumn) return true;
return fromColumn.dataType === toColumn.dataType;
};
```
#### 시각적 피드백
```typescript
// TO 컬럼 렌더링 시 상태 표시
const getToColumnStatus = (toColumn: ColumnInfo) => {
const mapping = columnMappings.find(
(m) => m.toColumnName === toColumn.columnName
);
if (mapping?.fromColumnName) {
return {
status: "mapped",
color: "bg-green-100 border-green-300",
icon: "🔗",
label: `← ${mapping.fromColumnName}`,
};
}
if (mapping?.defaultValue) {
return {
status: "default",
color: "bg-blue-100 border-blue-300",
icon: "📝",
label: `기본값: ${mapping.defaultValue}`,
};
}
return {
status: "unmapped",
color: "bg-gray-100 border-gray-300",
icon: "⚪",
label: "미설정",
};
};
```
## 📊 데이터 플로우
### 1. 설정 저장 플로우
```
사용자 설정 입력
↓
ConnectionSelectionPanel → 커넥션 ID 저장
↓
TableSelectionPanel → 테이블명 저장
↓
InsertFieldMappingPanel → 필드 매핑 저장
↓
DataSaveSettings 업데이트
↓
dataflow_diagrams.plan 필드에 JSON 저장
```
### 2. 실행 플로우
#### INSERT 실행 플로우
```
제어관리 트리거 발생 (INSERT)
↓
EnhancedDataflowControlService.executeDataflowControl()
↓
소스 커넥션에서 데이터 조회 (MultiConnectionQueryService.fetchDataFromConnection)
↓
필드 매핑 규칙 적용 (1:N 매핑 지원)
↓
대상 커넥션에 데이터 삽입 (MultiConnectionQueryService.insertDataToConnection)
↓
결과 반환
```
#### UPDATE 실행 플로우
```
제어관리 트리거 발생 (UPDATE)
↓
EnhancedDataflowControlService.executeDataflowControl()
↓
소스 커넥션에서 조건 데이터 조회 (UPDATE 조건 확인)
↓
조건 만족 시 FROM 데이터 추출
↓
필드 매핑 규칙 적용 (FROM → TO 필드 매핑)
↓
WHERE 조건 생성 (TO 테이블 대상 레코드 식별)
↓
대상 커넥션에서 데이터 업데이트 (MultiConnectionQueryService.updateDataToConnection)
↓
결과 반환
```
#### DELETE 실행 플로우
```
제어관리 트리거 발생 (DELETE)
↓
EnhancedDataflowControlService.executeDataflowControl()
↓
소스 커넥션에서 삭제 트리거 조건 확인
↓
조건 만족 시 삭제 대상 식별
↓
안전장치 검증 (maxDeleteCount, WHERE 조건 필수)
↓
WHERE 조건 생성 (TO 테이블 삭제 대상 레코드)
↓
[dryRunFirst=true인 경우] 삭제 예상 개수 확인
↓
대상 커넥션에서 데이터 삭제 (MultiConnectionQueryService.deleteDataFromConnection)
↓
삭제 로그 기록 (logAllDeletes=true인 경우)
↓
결과 반환
```
## 🛠️ 기술적 고려사항
### 1. 성능 최적화
- **커넥션 풀링**: 외부 DB별 커넥션 풀 관리
- **캐싱**: 테이블/컬럼 정보 캐싱 (Redis 활용)
- **비동기 처리**: 대용량 데이터 처리 시 큐잉 시스템 활용
### 2. 보안 강화
- **커넥션 정보 암호화**: 기존 시스템과 동일한 수준 유지
- **접근 권한 관리**: 회사별 커넥션 접근 제어
- **감사 로깅**: 모든 외부 DB 접근 기록
### 3. 오류 처리
```typescript
export class ConnectionError extends Error {
constructor(
message: string,
public connectionId: number,
public originalError?: Error
) {
super(message);
this.name = "ConnectionError";
}
}
export class MappingValidationError extends Error {
constructor(message: string, public mappingErrors: ValidationError[]) {
super(message);
this.name = "MappingValidationError";
}
}
```
### 4. 호환성 유지
- **기존 설정 마이그레이션**: 기존 제어관리 설정을 새 구조로 자동 변환
- **점진적 전환**: 기존 기능 유지하면서 새 기능 추가
- **롤백 계획**: 문제 발생 시 이전 버전으로 복원 가능
## 📅 일정 계획
### Week 1-2: 백엔드 인프라
- [ ] MultiConnectionQueryService 개발
- [ ] 외부 커넥션 API 확장
- [ ] EnhancedDataflowControlService 개발
### Week 3-4: 프론트엔드 UI
- [ ] ConnectionSelectionPanel 개발 (액션 타입별 라벨링)
- [ ] TableSelectionPanel 개발 (액션 타입 지원)
- [ ] InsertFieldMappingPanel 확장
- [ ] UpdateFieldMappingPanel 개발
- [ ] DeleteConditionPanel 개발
### Week 5: 통합 및 테스트
- [ ] 컴포넌트 통합
- [ ] 매핑 제약사항 검증 로직
- [ ] 종합 테스트
### Week 6: 문서화 및 배포
- [ ] 사용자 가이드 작성
- [ ] 개발자 문서 업데이트
- [ ] 배포 및 사용자 교육
## 🎯 성공 지표
### 기능적 지표
- ✅ 다양한 외부 DB에 INSERT/UPDATE/DELETE 성공률 > 95%
- ✅ 매핑 제약사항 검증 정확도 100%
- ✅ DELETE 안전장치 동작률 100%
- ✅ 기존 제어관리 기능 호환성 100%
### 성능 지표
- ✅ 커넥션 설정 UI 응답 시간 < 2초
- ✅ 테이블/컬럼 로딩 시간 < 3초
- ✅ INSERT/UPDATE/DELETE 처리 시간 < 5초
- ✅ 대량 DELETE 검증 시간 < 3초
### 사용성 지표
- ✅ 설정 완료까지 필요한 클릭 수 < 10회
- ✅ 매핑 오류 발생 시 명확한 안내 메시지 제공
- ✅ 기존 사용자의 학습 비용 최소화
## 💡 자기 자신 테이블 작업 실제 사용 케이스
### 1. UPDATE 사용 케이스
#### 케이스 1: 사용자 로그인 정보 업데이트
```sql
-- 트리거: 사용자가 로그인할 때
-- FROM: login_logs 테이블에서 최근 로그인 기록 확인
-- TO: user_info 테이블의 last_login, login_count 업데이트
IF (login_logs.status = 'success' AND login_logs.created_at > NOW() - INTERVAL '1 minute')
THEN UPDATE user_info
SET last_login = login_logs.created_at,
login_count = login_count + 1,
updated_at = NOW()
WHERE user_info.user_id = login_logs.user_id
```
#### 케이스 2: 재고 수량 실시간 업데이트
```sql
-- 트리거: 주문이 완료될 때
-- FROM: order_items 테이블에서 주문 수량 확인
-- TO: product_inventory 테이블의 재고 수량 차감
IF (order_items.status = 'confirmed')
THEN UPDATE product_inventory
SET current_stock = current_stock - order_items.quantity,
last_updated = NOW()
WHERE product_inventory.product_id = order_items.product_id
```
### 2. DELETE 사용 케이스
#### 케이스 1: 임시 데이터 자동 정리
```sql
-- 트리거: 배치 작업 완료 시
-- FROM: batch_jobs 테이블에서 완료된 작업 확인
-- TO: temp_processing_data 테이블의 임시 데이터 삭제
IF (batch_jobs.status = 'completed' AND batch_jobs.completed_at < NOW() - INTERVAL '1 hour')
THEN DELETE FROM temp_processing_data
WHERE temp_processing_data.batch_id = batch_jobs.batch_id
AND temp_processing_data.status = 'processed'
LIMIT 100
```
#### 케이스 2: 만료된 세션 정리
```sql
-- 트리거: 시스템 정리 작업 시
-- FROM: user_sessions 테이블에서 만료된 세션 확인
-- TO: user_sessions 테이블에서 만료된 세션 삭제
IF (user_sessions.last_activity < NOW() - INTERVAL '24 hours')
THEN DELETE FROM user_sessions
WHERE user_sessions.last_activity < NOW() - INTERVAL '24 hours'
AND user_sessions.status = 'inactive'
LIMIT 50
```
### 3. 복합 시나리오
#### 케이스 3: 주문 상태 변경에 따른 연쇄 업데이트
```sql
-- 1단계: 주문 상태 업데이트
UPDATE orders SET status = 'shipped', shipped_at = NOW()
WHERE order_id = 'ORD001' AND status = 'processing'
-- 2단계: 배송 정보 생성 (INSERT)
INSERT INTO shipping_info (order_id, tracking_number, created_at)
VALUES ('ORD001', 'TRACK001', NOW())
-- 3단계: 고객 주문 이력 업데이트
UPDATE customer_stats
SET total_orders = total_orders + 1, last_order_date = NOW()
WHERE customer_id = (SELECT customer_id FROM orders WHERE order_id = 'ORD001')
```
## 🚀 향후 확장 계획
### Phase 4: 고급 기능
- **데이터 변환 함수**: 필드 매핑 시 커스텀 변환 로직 지원
- **배치 처리**: 대용량 데이터 일괄 처리
- **스케줄링**: 정기적 데이터 동기화
- **🆕 자기 자신 테이블 트랜잭션**: 복잡한 자기 참조 작업의 원자성 보장
### Phase 5: 모니터링
- **실시간 모니터링**: 외부 DB 연결 상태 실시간 추적
- **성능 분석**: 쿼리 실행 시간 및 리소스 사용량 분석
- **알림 시스템**: 오류 발생 시 자동 알림
- **🆕 자기 자신 테이블 작업 감시**: 위험한 자기 참조 작업 모니터링
### Phase 6: 안전성 강화
- **🆕 Dry Run 모드**: 실제 실행 전 결과 예측
- **🆕 롤백 시스템**: 자기 자신 테이블 작업 시 자동 백업 및 복원
- **🆕 단계별 승인**: 위험한 자기 참조 작업에 대한 관리자 승인 프로세스
이 계획서를 바탕으로 체계적이고 안전한 제어관리 기능 개선을 진행할 수 있습니다.
Reference in New Issue View Git Blame Copy Permalink