ERP-node/PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md

# 🚀 Prisma → Raw Query 완전 전환 계획서

## 📋 프로젝트 개요

### 🎯 목적

현재 Node.js 백엔드에서 Prisma ORM을 완전히 제거하고 Raw Query 방식으로 전환하여 **완전 동적 테이블 생성 및 관리 시스템**을 구축합니다.

### 🔍 현재 상황 분석

- **총 42개 파일**에서 Prisma 사용
- **386개의 Prisma 호출** (ORM + Raw Query 혼재)
- **150개 이상의 테이블** 정의 (schema.prisma)
- **복잡한 트랜잭션 및 동적 쿼리** 다수 존재

---

## 📊 Prisma 사용 현황 분석

### 1. **Prisma 사용 파일 분류**

#### 🔴 **High Priority (핵심 서비스)**

```
backend-node/src/services/
├── authService.ts                    # 인증 (5개 호출)
├── dynamicFormService.ts             # 동적 폼 (14개 호출)
├── dataflowControlService.ts         # 제어관리 (6개 호출)
├── multiConnectionQueryService.ts    # 다중 연결 (4개 호출)
├── tableManagementService.ts         # 테이블 관리 (34개 호출)
├── screenManagementService.ts        # 화면 관리 (40개 호출)
└── ddlExecutionService.ts            # DDL 실행 (4개 호출)
```

#### 🟡 **Medium Priority (관리 기능)**

```
backend-node/src/services/
├── adminService.ts                   # 관리자 (3개 호출)
├── multilangService.ts               # 다국어 (22개 호출)
├── commonCodeService.ts              # 공통코드 (13개 호출)
├── externalDbConnectionService.ts    # 외부DB (15개 호출)
├── batchService.ts                   # 배치 (13개 호출)
└── eventTriggerService.ts            # 이벤트 (6개 호출)
```

#### 🟢 **Low Priority (부가 기능)**

```
backend-node/src/services/
├── layoutService.ts                  # 레이아웃 (8개 호출)
├── componentStandardService.ts       # 컴포넌트 (11개 호출)
├── templateStandardService.ts        # 템플릿 (8개 호출)
├── collectionService.ts              # 컬렉션 (11개 호출)
└── referenceCacheService.ts          # 캐시 (3개 호출)
```

### 2. **복잡도별 분류**

#### 🔥 **매우 복잡 (트랜잭션 + 동적 쿼리)**

- `dataflowControlService.ts` - 복잡한 제어 로직
- `enhancedDataflowControlService.ts` - 다중 연결 제어
- `dynamicFormService.ts` - UPSERT 및 동적 테이블 처리
- `multiConnectionQueryService.ts` - 외부 DB 연결

#### 🟠 **복잡 (Raw Query 혼재)**

- `tableManagementService.ts` - 테이블 메타데이터 관리
- `screenManagementService.ts` - 화면 정의 관리
- `eventTriggerService.ts` - JSON 검색 쿼리

#### 🟡 **중간 (단순 CRUD)**

- `authService.ts` - 사용자 인증
- `adminService.ts` - 관리자 메뉴
- `commonCodeService.ts` - 코드 관리

---

## 🏗️ Raw Query 아키텍처 설계

### 1. **새로운 데이터베이스 매니저**

```typescript
// config/databaseManager.ts
import { Pool, PoolClient } from "pg";

export class DatabaseManager {
  private static pool: Pool;

  static initialize() {
    this.pool = new Pool({
      host: process.env.DB_HOST,
      port: parseInt(process.env.DB_PORT || "5432"),
      database: process.env.DB_NAME,
      user: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      max: 20,
      idleTimeoutMillis: 30000,
      connectionTimeoutMillis: 2000,
    });
  }

  // 기본 쿼리 실행
  static async query(text: string, params?: any[]): Promise<any[]> {
    const client = await this.pool.connect();
    try {
      const result = await client.query(text, params);
      return result.rows;
    } finally {
      client.release();
    }
  }

  // 트랜잭션 실행
  static async transaction<T>(
    callback: (client: PoolClient) => Promise<T>
  ): Promise<T> {
    const client = await this.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 close() {
    await this.pool.end();
  }
}
```

### 2. **동적 쿼리 빌더**

```typescript
// utils/queryBuilder.ts
export class QueryBuilder {
  // SELECT 쿼리 빌더
  static select(
    tableName: string,
    options: {
      columns?: string[];
      where?: Record<string, any>;
      orderBy?: string;
      limit?: number;
      offset?: number;
      joins?: Array<{
        type: "INNER" | "LEFT" | "RIGHT";
        table: string;
        on: string;
      }>;
    } = {}
  ) {
    const {
      columns = ["*"],
      where = {},
      orderBy,
      limit,
      offset,
      joins = [],
    } = options;

    let query = `SELECT ${columns.join(", ")} FROM ${tableName}`;
    const params: any[] = [];
    let paramIndex = 1;

    // JOIN 처리
    joins.forEach((join) => {
      query += ` ${join.type} JOIN ${join.table} ON ${join.on}`;
    });

    // WHERE 조건
    if (Object.keys(where).length > 0) {
      const whereClause = Object.keys(where)
        .map((key) => `${key} = $${paramIndex++}`)
        .join(" AND ");
      query += ` WHERE ${whereClause}`;
      params.push(...Object.values(where));
    }

    // ORDER BY
    if (orderBy) {
      query += ` ORDER BY ${orderBy}`;
    }

    // LIMIT/OFFSET
    if (limit) {
      query += ` LIMIT $${paramIndex++}`;
      params.push(limit);
    }
    if (offset) {
      query += ` OFFSET $${paramIndex++}`;
      params.push(offset);
    }

    return { query, params };
  }

  // INSERT 쿼리 빌더
  static insert(
    tableName: string,
    data: Record<string, any>,
    options: {
      returning?: string[];
      onConflict?: {
        columns: string[];
        action: "DO NOTHING" | "DO UPDATE";
        updateSet?: string[];
      };
    } = {}
  ) {
    const columns = Object.keys(data);
    const values = Object.values(data);
    const placeholders = values.map((_, index) => `$${index + 1}`).join(", ");

    let query = `INSERT INTO ${tableName} (${columns.join(
      ", "
    )}) VALUES (${placeholders})`;

    // ON CONFLICT 처리 (UPSERT)
    if (options.onConflict) {
      const {
        columns: conflictColumns,
        action,
        updateSet,
      } = options.onConflict;
      query += ` ON CONFLICT (${conflictColumns.join(", ")}) ${action}`;

      if (action === "DO UPDATE" && updateSet) {
        const setClause = updateSet
          .map((col) => `${col} = EXCLUDED.${col}`)
          .join(", ");
        query += ` SET ${setClause}`;
      }
    }

    // RETURNING 처리
    if (options.returning) {
      query += ` RETURNING ${options.returning.join(", ")}`;
    }

    return { query, params: values };
  }

  // UPDATE 쿼리 빌더
  static update(
    tableName: string,
    data: Record<string, any>,
    where: Record<string, any>
  ) {
    const setClause = Object.keys(data)
      .map((key, index) => `${key} = $${index + 1}`)
      .join(", ");

    const whereClause = Object.keys(where)
      .map((key, index) => `${key} = $${Object.keys(data).length + index + 1}`)
      .join(" AND ");

    const query = `UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;
    const params = [...Object.values(data), ...Object.values(where)];

    return { query, params };
  }

  // DELETE 쿼리 빌더
  static delete(tableName: string, where: Record<string, any>) {
    const whereClause = Object.keys(where)
      .map((key, index) => `${key} = $${index + 1}`)
      .join(" AND ");

    const query = `DELETE FROM ${tableName} WHERE ${whereClause} RETURNING *`;
    const params = Object.values(where);

    return { query, params };
  }
}
```

### 3. **타입 안전성 보장**

```typescript
// types/database.ts
export interface QueryResult<T = any> {
  rows: T[];
  rowCount: number;
  command: string;
}

export interface TableSchema {
  tableName: string;
  columns: ColumnDefinition[];
}

export interface ColumnDefinition {
  name: string;
  type: string;
  nullable?: boolean;
  defaultValue?: string;
  isPrimaryKey?: boolean;
}

// 런타임 검증
export class DatabaseValidator {
  static validateTableName(tableName: string): boolean {
    return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName) && tableName.length <= 63;
  }

  static validateColumnName(columnName: string): boolean {
    return (
      /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(columnName) && columnName.length <= 63
    );
  }

  static sanitizeInput(input: any): any {
    if (typeof input === "string") {
      return input.replace(/[';--]/g, "");
    }
    return input;
  }

  static validateWhereClause(where: Record<string, any>): boolean {
    return Object.keys(where).every((key) => this.validateColumnName(key));
  }
}
```

---

## 📅 단계별 마이그레이션 계획

### **Phase 1: 기반 구조 구축 (1주)**

#### 1.1 새로운 데이터베이스 아키텍처 구현

- [ ] `DatabaseManager` 클래스 구현
- [ ] `QueryBuilder` 유틸리티 구현
- [ ] 타입 정의 및 검증 로직 구현
- [ ] 연결 풀 및 트랜잭션 관리

#### 1.2 테스트 환경 구축

- [ ] 단위 테스트 작성
- [ ] 통합 테스트 환경 구성
- [ ] 성능 벤치마크 도구 준비

### **Phase 2: 핵심 서비스 전환 (2주)**

#### 2.1 인증 서비스 전환 (우선순위 1)

```typescript
// 기존 Prisma 코드
const userInfo = await prisma.user_info.findUnique({
  where: { user_id: userId },
});

// 새로운 Raw Query 코드
const { query, params } = QueryBuilder.select("user_info", {
  where: { user_id: userId },
});
const userInfo = await DatabaseManager.query(query, params);
```

#### 2.2 동적 폼 서비스 전환 (우선순위 2)

- [ ] UPSERT 로직 Raw Query로 전환
- [ ] 동적 테이블 처리 로직 개선
- [ ] 트랜잭션 처리 최적화

#### 2.3 제어관리 서비스 전환 (우선순위 3)

- [ ] 복잡한 조건부 쿼리 전환
- [ ] 다중 테이블 업데이트 로직 개선
- [ ] 에러 핸들링 강화

### **Phase 3: 관리 기능 전환 (1.5주)**

#### 3.1 테이블 관리 서비스

- [ ] 메타데이터 조회 쿼리 전환
- [ ] 동적 컬럼 추가/삭제 로직
- [ ] 인덱스 관리 기능

#### 3.2 화면 관리 서비스

- [ ] JSON 데이터 처리 최적화
- [ ] 복잡한 조인 쿼리 전환
- [ ] 캐싱 메커니즘 구현

#### 3.3 다국어 서비스

- [ ] 재귀 쿼리 (WITH RECURSIVE) 전환
- [ ] 번역 데이터 관리 최적화

### **Phase 4: 부가 기능 전환 (1주)**

#### 4.1 배치 및 외부 연결

- [ ] 배치 스케줄러 전환
- [ ] 외부 DB 연결 관리
- [ ] 로그 및 모니터링

#### 4.2 표준 관리 기능

- [ ] 컴포넌트 표준 관리
- [ ] 템플릿 표준 관리
- [ ] 레이아웃 관리

### **Phase 5: Prisma 완전 제거 (0.5주)**

#### 5.1 Prisma 의존성 제거

- [ ] `package.json`에서 Prisma 제거
- [ ] `schema.prisma` 파일 삭제
- [ ] 관련 설정 파일 정리

#### 5.2 최종 검증 및 최적화

- [ ] 전체 기능 테스트
- [ ] 성능 최적화
- [ ] 문서화 업데이트

---

## 🔄 마이그레이션 전략

### 1. **점진적 전환 방식**

#### 단계별 전환

```typescript
// 1단계: 기존 Prisma 코드 유지하면서 Raw Query 병행
class AuthService {
  // 기존 방식 (임시 유지)
  async loginWithPrisma(userId: string) {
    return await prisma.user_info.findUnique({
      where: { user_id: userId },
    });
  }

  // 새로운 방식 (점진적 도입)
  async loginWithRawQuery(userId: string) {
    const { query, params } = QueryBuilder.select("user_info", {
      where: { user_id: userId },
    });
    return await DatabaseManager.query(query, params);
  }
}

// 2단계: 기존 메서드를 새로운 방식으로 교체
class AuthService {
  async login(userId: string) {
    return await this.loginWithRawQuery(userId);
  }
}

// 3단계: 기존 코드 완전 제거
```

### 2. **호환성 레이어**

```typescript
// utils/prismaCompatibility.ts
export class PrismaCompatibilityLayer {
  // 기존 Prisma 호출을 Raw Query로 변환하는 어댑터
  static async findUnique(model: string, options: any) {
    const { where } = options;
    const { query, params } = QueryBuilder.select(model, { where });
    const results = await DatabaseManager.query(query, params);
    return results[0] || null;
  }

  static async findMany(model: string, options: any = {}) {
    const { where, orderBy, take: limit, skip: offset } = options;
    const { query, params } = QueryBuilder.select(model, {
      where,
      orderBy,
      limit,
      offset,
    });
    return await DatabaseManager.query(query, params);
  }

  static async create(model: string, options: any) {
    const { data } = options;
    const { query, params } = QueryBuilder.insert(model, data, {
      returning: ["*"],
    });
    const results = await DatabaseManager.query(query, params);
    return results[0];
  }
}
```

### 3. **테스트 전략**

#### 병렬 테스트

```typescript
// tests/migration.test.ts
describe("Prisma to Raw Query Migration", () => {
  test("AuthService: 동일한 결과 반환", async () => {
    const userId = "test_user";

    // 기존 Prisma 결과
    const prismaResult = await authService.loginWithPrisma(userId);

    // 새로운 Raw Query 결과
    const rawQueryResult = await authService.loginWithRawQuery(userId);

    // 결과 비교
    expect(rawQueryResult).toEqual(prismaResult);
  });
});
```

---

## 🚨 위험 요소 및 대응 방안

### 1. **데이터 일관성 위험**

#### 위험 요소

- 트랜잭션 처리 미스
- 타입 변환 오류
- NULL 처리 차이

#### 대응 방안

```typescript
// 엄격한 트랜잭션 관리
export class TransactionManager {
  static async executeInTransaction<T>(
    operations: ((client: PoolClient) => Promise<T>)[]
  ): Promise<T[]> {
    return await DatabaseManager.transaction(async (client) => {
      const results: T[] = [];
      for (const operation of operations) {
        const result = await operation(client);
        results.push(result);
      }
      return results;
    });
  }
}

// 타입 안전성 검증
export class TypeConverter {
  static toPostgresType(value: any, expectedType: string): any {
    switch (expectedType) {
      case "integer":
        return parseInt(value) || null;
      case "decimal":
        return parseFloat(value) || null;
      case "boolean":
        return Boolean(value);
      case "timestamp":
        return value ? new Date(value) : null;
      default:
        return value;
    }
  }
}
```

### 2. **성능 저하 위험**

#### 위험 요소

- 연결 풀 관리 미흡
- 쿼리 최적화 부족
- 캐싱 메커니즘 부재

#### 대응 방안

```typescript
// 연결 풀 최적화
export class ConnectionPoolManager {
  private static readonly DEFAULT_POOL_CONFIG = {
    min: 2,
    max: 20,
    acquireTimeoutMillis: 30000,
    createTimeoutMillis: 30000,
    destroyTimeoutMillis: 5000,
    idleTimeoutMillis: 30000,
    reapIntervalMillis: 1000,
    createRetryIntervalMillis: 200,
  };
}

// 쿼리 캐싱
export class QueryCache {
  private static cache = new Map<string, { data: any; timestamp: number }>();
  private static readonly CACHE_TTL = 5 * 60 * 1000; // 5분

  static get(key: string): any | null {
    const cached = this.cache.get(key);
    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
      return cached.data;
    }
    this.cache.delete(key);
    return null;
  }

  static set(key: string, data: any): void {
    this.cache.set(key, { data, timestamp: Date.now() });
  }
}
```

### 3. **개발 생산성 저하**

#### 위험 요소

- 타입 안전성 부족
- 디버깅 어려움
- 코드 복잡성 증가

#### 대응 방안

```typescript
// 개발자 친화적 인터페이스
export class DatabaseORM {
  // Prisma와 유사한 인터페이스 제공
  user_info = {
    findUnique: (options: { where: Record<string, any> }) =>
      PrismaCompatibilityLayer.findUnique("user_info", options),

    findMany: (options?: any) =>
      PrismaCompatibilityLayer.findMany("user_info", options),

    create: (options: { data: Record<string, any> }) =>
      PrismaCompatibilityLayer.create("user_info", options),
  };

  // 다른 테이블들도 동일한 패턴으로 구현
}

// 디버깅 도구
export class QueryLogger {
  static log(query: string, params: any[], executionTime: number) {
    if (process.env.NODE_ENV === "development") {
      console.log(`🔍 Query: ${query}`);
      console.log(`📊 Params: ${JSON.stringify(params)}`);
      console.log(`⏱️  Time: ${executionTime}ms`);
    }
  }
}
```

---

## 📈 성능 최적화 전략

### 1. **연결 풀 최적화**

```typescript
// config/optimizedPool.ts
export class OptimizedPoolConfig {
  static getConfig() {
    return {
      // 환경별 최적화된 설정
      max: process.env.NODE_ENV === "production" ? 20 : 5,
      min: process.env.NODE_ENV === "production" ? 5 : 2,

      // 연결 타임아웃 최적화
      acquireTimeoutMillis: 30000,
      createTimeoutMillis: 30000,

      // 유휴 연결 관리
      idleTimeoutMillis: 600000, // 10분

      // 연결 검증
      testOnBorrow: true,
      validationQuery: "SELECT 1",
    };
  }
}
```

### 2. **쿼리 최적화**

```typescript
// utils/queryOptimizer.ts
export class QueryOptimizer {
  // 인덱스 힌트 추가
  static addIndexHint(query: string, indexName: string): string {
    return query.replace(
      /FROM\s+(\w+)/i,
      `FROM $1 /*+ INDEX($1 ${indexName}) */`
    );
  }

  // 쿼리 분석 및 최적화 제안
  static analyzeQuery(query: string): QueryAnalysis {
    return {
      hasIndex: this.checkIndexUsage(query),
      estimatedRows: this.estimateRowCount(query),
      suggestions: this.generateOptimizationSuggestions(query),
    };
  }
}
```

### 3. **캐싱 전략**

```typescript
// utils/smartCache.ts
export class SmartCache {
  private static redis: Redis; // Redis 클라이언트

  // 테이블별 캐시 전략
  static async get(key: string, tableName: string): Promise<any> {
    const cacheConfig = this.getCacheConfig(tableName);

    if (!cacheConfig.enabled) return null;

    const cached = await this.redis.get(key);
    return cached ? JSON.parse(cached) : null;
  }

  static async set(key: string, data: any, tableName: string): Promise<void> {
    const cacheConfig = this.getCacheConfig(tableName);

    if (cacheConfig.enabled) {
      await this.redis.setex(key, cacheConfig.ttl, JSON.stringify(data));
    }
  }

  private static getCacheConfig(tableName: string) {
    const configs = {
      user_info: { enabled: true, ttl: 300 }, // 5분
      menu_info: { enabled: true, ttl: 600 }, // 10분
      dynamic_tables: { enabled: false, ttl: 0 }, // 동적 테이블은 캐시 안함
    };

    return configs[tableName] || { enabled: false, ttl: 0 };
  }
}
```

---

## 🧪 테스트 전략

### 1. **단위 테스트**

```typescript
// tests/unit/queryBuilder.test.ts
describe("QueryBuilder", () => {
  test("SELECT 쿼리 생성", () => {
    const { query, params } = QueryBuilder.select("user_info", {
      where: { user_id: "test" },
      limit: 10,
    });

    expect(query).toBe("SELECT * FROM user_info WHERE user_id = $1 LIMIT $2");
    expect(params).toEqual(["test", 10]);
  });

  test("복잡한 JOIN 쿼리", () => {
    const { query, params } = QueryBuilder.select("user_info", {
      joins: [
        {
          type: "LEFT",
          table: "dept_info",
          on: "user_info.dept_code = dept_info.dept_code",
        },
      ],
      where: { "user_info.status": "active" },
    });

    expect(query).toContain("LEFT JOIN dept_info");
    expect(query).toContain("WHERE user_info.status = $1");
  });
});
```

### 2. **통합 테스트**

```typescript
// tests/integration/migration.test.ts
describe("Migration Integration Tests", () => {
  let prismaService: any;
  let rawQueryService: any;

  beforeAll(async () => {
    // 테스트 데이터베이스 설정
    await setupTestDatabase();
  });

  test("동일한 결과 반환 - 사용자 조회", async () => {
    const testUserId = "integration_test_user";

    const prismaResult = await prismaService.getUser(testUserId);
    const rawQueryResult = await rawQueryService.getUser(testUserId);

    expect(normalizeResult(rawQueryResult)).toEqual(
      normalizeResult(prismaResult)
    );
  });

  test("트랜잭션 일관성 - 복잡한 업데이트", async () => {
    const testData = {
      /* 테스트 데이터 */
    };

    // Prisma 트랜잭션
    const prismaResult = await prismaService.complexUpdate(testData);

    // Raw Query 트랜잭션
    const rawQueryResult = await rawQueryService.complexUpdate(testData);

    expect(rawQueryResult.success).toBe(prismaResult.success);
  });
});
```

### 3. **성능 테스트**

```typescript
// tests/performance/benchmark.test.ts
describe("Performance Benchmarks", () => {
  test("대량 데이터 조회 성능", async () => {
    const iterations = 1000;

    // Prisma 성능 측정
    const prismaStart = Date.now();
    for (let i = 0; i < iterations; i++) {
      await prismaService.getLargeDataset();
    }
    const prismaTime = Date.now() - prismaStart;

    // Raw Query 성능 측정
    const rawQueryStart = Date.now();
    for (let i = 0; i < iterations; i++) {
      await rawQueryService.getLargeDataset();
    }
    const rawQueryTime = Date.now() - rawQueryStart;

    console.log(`Prisma: ${prismaTime}ms, Raw Query: ${rawQueryTime}ms`);

    // Raw Query가 더 빠르거나 비슷해야 함
    expect(rawQueryTime).toBeLessThanOrEqual(prismaTime * 1.1);
  });
});
```

---

## 📋 체크리스트

### **Phase 1: 기반 구조 (1주)**

- [ ] DatabaseManager 클래스 구현
- [ ] QueryBuilder 유틸리티 구현
- [ ] 타입 정의 및 검증 로직
- [ ] 연결 풀 설정 및 최적화
- [ ] 트랜잭션 관리 시스템
- [ ] 에러 핸들링 메커니즘
- [ ] 로깅 및 모니터링 도구
- [ ] 단위 테스트 작성

### **Phase 2: 핵심 서비스 (2주)**

- [ ] AuthService 전환 및 테스트
- [ ] DynamicFormService 전환 (UPSERT 포함)
- [ ] DataflowControlService 전환 (복잡한 로직)
- [ ] MultiConnectionQueryService 전환
- [ ] TableManagementService 전환
- [ ] ScreenManagementService 전환
- [ ] DDLExecutionService 전환
- [ ] 통합 테스트 실행

### **Phase 3: 관리 기능 (1.5주)**

- [ ] AdminService 전환
- [ ] MultiLangService 전환 (재귀 쿼리)
- [ ] CommonCodeService 전환
- [ ] ExternalDbConnectionService 전환
- [ ] BatchService 및 관련 서비스 전환
- [ ] EventTriggerService 전환
- [ ] 기능별 테스트 완료

### **Phase 4: 부가 기능 (1주)**

- [ ] LayoutService 전환
- [ ] ComponentStandardService 전환
- [ ] TemplateStandardService 전환
- [ ] CollectionService 전환
- [ ] ReferenceCacheService 전환
- [ ] 기타 컨트롤러 전환
- [ ] 전체 기능 테스트

### **Phase 5: 완전 제거 (0.5주)**

- [ ] Prisma 의존성 제거
- [ ] schema.prisma 삭제
- [ ] 관련 설정 파일 정리
- [ ] 문서 업데이트
- [ ] 최종 성능 테스트
- [ ] 배포 준비

---

## 🎯 성공 기준

### **기능적 요구사항**

- [ ] 모든 기존 기능이 동일하게 작동
- [ ] 동적 테이블 생성/관리 완벽 지원
- [ ] 트랜잭션 일관성 보장
- [ ] 에러 처리 및 복구 메커니즘

### **성능 요구사항**

- [ ] 기존 대비 성능 저하 없음 (±10% 이내)
- [ ] 메모리 사용량 최적화
- [ ] 연결 풀 효율성 개선
- [ ] 쿼리 실행 시간 단축

### **품질 요구사항**

- [ ] 코드 커버리지 90% 이상
- [ ] 모든 테스트 케이스 통과
- [ ] 타입 안전성 보장
- [ ] 보안 검증 완료

---

## 📚 참고 자료

### **기술 문서**

- [PostgreSQL 공식 문서](https://www.postgresql.org/docs/)
- [Node.js pg 라이브러리](https://node-postgres.com/)
- [SQL 쿼리 최적화 가이드](https://use-the-index-luke.com/)

### **내부 문서**

- [현재 데이터베이스 스키마](backend-node/prisma/schema.prisma)
- [기존 Java 시스템 구조](src/com/pms/)
- [동적 테이블 생성 계획서](테이블_동적_생성_기능_개발_계획서.md)

---

## ⚠️ 주의사항

1. **데이터 백업**: 마이그레이션 전 전체 데이터베이스 백업 필수
2. **점진적 전환**: 한 번에 모든 것을 바꾸지 말고 단계별로 진행
3. **철저한 테스트**: 각 단계마다 충분한 테스트 수행
4. **롤백 계획**: 문제 발생 시 즉시 롤백할 수 있는 계획 수립
5. **모니터링**: 전환 후 성능 및 안정성 지속 모니터링

---

**총 예상 기간: 6주**
**핵심 개발자: 2-3명**
**위험도: 중간 (적절한 계획과 테스트로 관리 가능)**

이 계획을 통해 Prisma를 완전히 제거하고 진정한 동적 데이터베이스 시스템을 구축할 수 있습니다! 🚀