294 changed files with 8321 additions and 67654 deletions
--- a/.cursor/rules/multilang-component-guide.mdc
+++ b/.cursor/rules/multilang-component-guide.mdc
@ -1,559 +0,0 @@
 # 다국어 지원 컴포넌트 개발 가이드
 새로운 화면 컴포넌트를 개발할 때 반드시 다국어 시스템을 고려해야 합니다.
 이 가이드는 컴포넌트가 다국어 자동 생성 및 매핑 시스템과 호환되도록 하는 방법을 설명합니다.
 ---
 ## 1. 타입 정의 시 다국어 필드 추가
 ### 기본 원칙
 텍스트가 표시되는 **모든 속성**에 `langKeyId`와 `langKey` 필드를 함께 정의해야 합니다.
 ### 단일 텍스트 속성
 ```typescript
 interface MyComponentConfig {
  // 기본 텍스트
  title?: string;
  // 다국어 키 (필수 추가)
  titleLangKeyId?: number;
  titleLangKey?: string;
  // 라벨
  label?: string;
  labelLangKeyId?: number;
  labelLangKey?: string;
  // 플레이스홀더
  placeholder?: string;
  placeholderLangKeyId?: number;
  placeholderLangKey?: string;
 }
 ```
 ### 배열/목록 속성 (컬럼, 탭 등)
 ```typescript
 interface ColumnConfig {
  name: string;
  label: string;
  // 다국어 키 (필수 추가)
  langKeyId?: number;
  langKey?: string;
  // 기타 속성
  width?: number;
  align?: "left" | "center" | "right";
 }
 interface TabConfig {
  id: string;
  label: string;
  // 다국어 키 (필수 추가)
  langKeyId?: number;
  langKey?: string;
  // 탭 제목도 별도로
  title?: string;
  titleLangKeyId?: number;
  titleLangKey?: string;
 }
 interface MyComponentConfig {
  columns?: ColumnConfig[];
  tabs?: TabConfig[];
 }
 ```
 ### 버튼 컴포넌트
 ```typescript
 interface ButtonComponentConfig {
  text?: string;
  // 다국어 키 (필수 추가)
  langKeyId?: number;
  langKey?: string;
 }
 ```
 ### 실제 예시: 분할 패널
 ```typescript
 interface SplitPanelLayoutConfig {
  leftPanel?: {
    title?: string;
    langKeyId?: number; // 좌측 패널 제목 다국어
    langKey?: string;
    columns?: Array<{
      name: string;
      label: string;
      langKeyId?: number; // 각 컬럼 다국어
      langKey?: string;
    }>;
  };
  rightPanel?: {
    title?: string;
    langKeyId?: number; // 우측 패널 제목 다국어
    langKey?: string;
    columns?: Array<{
      name: string;
      label: string;
      langKeyId?: number;
      langKey?: string;
    }>;
    additionalTabs?: Array<{
      label: string;
      langKeyId?: number; // 탭 라벨 다국어
      langKey?: string;
      title?: string;
      titleLangKeyId?: number; // 탭 제목 다국어
      titleLangKey?: string;
      columns?: Array<{
        name: string;
        label: string;
        langKeyId?: number;
        langKey?: string;
      }>;
    }>;
  };
 }
 ```
 ---
 ## 2. 라벨 추출 로직 등록
 ### 파일 위치
 `frontend/lib/utils/multilangLabelExtractor.ts`
 ### `extractMultilangLabels` 함수에 추가
 새 컴포넌트의 라벨을 추출하는 로직을 추가해야 합니다.
 ```typescript
 // 새 컴포넌트 타입 체크
 if (comp.componentType === "my-new-component") {
  const config = comp.componentConfig as MyComponentConfig;
  // 1. 제목 추출
  if (config?.title) {
    addLabel({
      id: `${comp.id}_title`,
      componentId: `${comp.id}_title`,-
      label: config.title,
      type: "title",
      parentType: "my-new-component",
      parentLabel: config.title,
      langKeyId: config.titleLangKeyId,
      langKey: config.titleLangKey,
    });
  }
  // 2. 컬럼 추출
  if (config?.columns && Array.isArray(config.columns)) {
    config.columns.forEach((col, index) => {
      const colLabel = col.label || col.name;
      addLabel({
        id: `${comp.id}_col_${index}`,
        componentId: `${comp.id}_col_${index}`,
        label: colLabel,
        type: "column",
        parentType: "my-new-component",
        parentLabel: config.title || "새 컴포넌트",
        langKeyId: col.langKeyId,
        langKey: col.langKey,
      });
    });
  }
  // 3. 버튼 텍스트 추출 (버튼 컴포넌트인 경우)
  if (config?.text) {
    addLabel({
      id: `${comp.id}_button`,
      componentId: `${comp.id}_button`,
      label: config.text,
      type: "button",
      parentType: "my-new-component",
      parentLabel: config.text,
      langKeyId: config.langKeyId,
      langKey: config.langKey,
    });
  }
 }
 ```
 ### 추출해야 할 라벨 타입
 | 타입          | 설명               | 예시                     |
 | ------------- | ------------------ | ------------------------ |
 | `title`       | 컴포넌트/패널 제목 | 분할패널 제목, 카드 제목 |
 | `label`       | 입력 필드 라벨     | 텍스트 입력 라벨         |
 | `button`      | 버튼 텍스트        | 저장, 취소, 삭제         |
 | `column`      | 테이블 컬럼 헤더   | 품목명, 수량, 금액       |
 | `tab`         | 탭 라벨            | 기본정보, 상세정보       |
 | `filter`      | 검색 필터 라벨     | 검색어, 기간             |
 | `placeholder` | 플레이스홀더       | "검색어를 입력하세요"    |
 | `action`      | 액션 버튼/링크     | 수정, 삭제, 상세보기     |
 ---
 ## 3. 매핑 적용 로직 등록
 ### 파일 위치
 `frontend/lib/utils/multilangLabelExtractor.ts`
 ### `applyMultilangMappings` 함수에 추가
 다국어 키가 선택되면 컴포넌트에 `langKeyId`와 `langKey`를 저장하는 로직을 추가합니다.
 ```typescript
 // 새 컴포넌트 매핑 적용
 if (comp.componentType === "my-new-component") {
  const config = comp.componentConfig as MyComponentConfig;
  // 1. 제목 매핑
  const titleMapping = mappingMap.get(`${comp.id}_title`);
  if (titleMapping) {
    updated.componentConfig = {
      ...updated.componentConfig,
      titleLangKeyId: titleMapping.keyId,
      titleLangKey: titleMapping.langKey,
    };
  }
  // 2. 컬럼 매핑
  if (config?.columns && Array.isArray(config.columns)) {
    const updatedColumns = config.columns.map((col, index) => {
      const colMapping = mappingMap.get(`${comp.id}_col_${index}`);
      if (colMapping) {
        return {
          ...col,
          langKeyId: colMapping.keyId,
          langKey: colMapping.langKey,
        };
      }
      return col;
    });
    updated.componentConfig = {
      ...updated.componentConfig,
      columns: updatedColumns,
    };
  }
  // 3. 버튼 매핑 (버튼 컴포넌트인 경우)
  const buttonMapping = mappingMap.get(`${comp.id}_button`);
  if (buttonMapping) {
    updated.componentConfig = {
      ...updated.componentConfig,
      langKeyId: buttonMapping.keyId,
      langKey: buttonMapping.langKey,
    };
  }
 }
 ```
 ### 주의사항
 - **객체 참조 유지**: 매핑 시 기존 `updated.componentConfig`를 기반으로 업데이트해야 합니다.
 - **중첩 구조**: 중첩된 객체(예: `leftPanel.columns`)는 상위 객체부터 순서대로 업데이트합니다.
 ```typescript
 // 잘못된 방법 - 이전 업데이트 덮어쓰기
 updated.componentConfig = { ...config, langKeyId: mapping.keyId }; // ❌
 updated.componentConfig = { ...config, columns: updatedColumns }; // langKeyId 사라짐!
 // 올바른 방법 - 이전 업데이트 유지
 updated.componentConfig = {
  ...updated.componentConfig,
  langKeyId: mapping.keyId,
 }; // ✅
 updated.componentConfig = {
  ...updated.componentConfig,
  columns: updatedColumns,
 }; // ✅
 ```
 ---
 ## 4. 번역 표시 로직 구현
 ### 파일 위치
 새 컴포넌트 파일 (예: `frontend/lib/registry/components/my-component/MyComponent.tsx`)
 ### Context 사용
 ```typescript
 import { useScreenMultiLang } from "@/contexts/ScreenMultiLangContext";
 const MyComponent = ({ component }: Props) => {
  const { getTranslatedText } = useScreenMultiLang();
  const config = component.componentConfig;
  // 제목 번역
  const displayTitle = config?.titleLangKey
    ? getTranslatedText(config.titleLangKey, config.title || "")
    : config?.title || "";
  // 컬럼 헤더 번역
  const translatedColumns = config?.columns?.map((col) => ({
    ...col,
    displayLabel: col.langKey
      ? getTranslatedText(col.langKey, col.label)
      : col.label,
  }));
  // 버튼 텍스트 번역
  const buttonText = config?.langKey
    ? getTranslatedText(config.langKey, config.text || "")
    : config?.text || "";
  return (
    <div>
      <h2>{displayTitle}</h2>
      <table>
        <thead>
          <tr>
            {translatedColumns?.map((col, idx) => (
              <th key={idx}>{col.displayLabel}</th>
            ))}
          </tr>
        </thead>
      </table>
      <button>{buttonText}</button>
    </div>
  );
 };
 ```
 ### getTranslatedText 함수
 ```typescript
 // 첫 번째 인자: langKey (다국어 키)
 // 두 번째 인자: fallback (키가 없거나 번역이 없을 때 기본값)
 const text = getTranslatedText(
  "screen.company_1.Sales.OrderList.품목명",
  "품목명"
 );
 ```
 ### 주의사항
 - `langKey`가 없으면 원본 텍스트를 표시합니다.
 - `useScreenMultiLang`은 반드시 `ScreenMultiLangProvider` 내부에서 사용해야 합니다.
 - 화면 페이지(`/screens/[screenId]/page.tsx`)에서 이미 Provider로 감싸져 있습니다.
 ---
 ## 5. ScreenMultiLangContext에 키 수집 로직 추가
 ### 파일 위치
 `frontend/contexts/ScreenMultiLangContext.tsx`
 ### `collectLangKeys` 함수에 추가
 번역을 미리 로드하기 위해 컴포넌트에서 사용하는 모든 `langKey`를 수집해야 합니다.
 ```typescript
 const collectLangKeys = (comps: ComponentData[]): Set<string> => {
  const keys = new Set<string>();
  const processComponent = (comp: ComponentData) => {
    const config = comp.componentConfig;
    // 새 컴포넌트의 langKey 수집
    if (comp.componentType === "my-new-component") {
      // 제목
      if (config?.titleLangKey) {
        keys.add(config.titleLangKey);
      }
      // 컬럼
      if (config?.columns && Array.isArray(config.columns)) {
        config.columns.forEach((col: any) => {
          if (col.langKey) {
            keys.add(col.langKey);
          }
        });
      }
      // 버튼
      if (config?.langKey) {
        keys.add(config.langKey);
      }
    }
    // 자식 컴포넌트 재귀 처리
    if (comp.children && Array.isArray(comp.children)) {
      comp.children.forEach(processComponent);
    }
  };
  comps.forEach(processComponent);
  return keys;
 };
 ```
 ---
 ## 6. MultilangSettingsModal에 표시 로직 추가
 ### 파일 위치
 `frontend/components/screen/modals/MultilangSettingsModal.tsx`
 ### `extractLabelsFromComponents` 함수에 추가
 다국어 설정 모달에서 새 컴포넌트의 라벨이 표시되도록 합니다.
 ```typescript
 // 새 컴포넌트 라벨 추출
 if (comp.componentType === "my-new-component") {
  const config = comp.componentConfig as MyComponentConfig;
  // 제목
  if (config?.title) {
    addLabel({
      id: `${comp.id}_title`,
      componentId: `${comp.id}_title`,
      label: config.title,
      type: "title",
      parentType: "my-new-component",
      parentLabel: config.title,
      langKeyId: config.titleLangKeyId,
      langKey: config.titleLangKey,
    });
  }
  // 컬럼
  if (config?.columns) {
    config.columns.forEach((col, index) => {
      // columnLabelMap에서 라벨 가져오기 (테이블 컬럼인 경우)
      const tableName = config.tableName;
      const displayLabel =
        tableName && columnLabelMap[tableName]?.[col.name]
          ? columnLabelMap[tableName][col.name]
          : col.label || col.name;
      addLabel({
        id: `${comp.id}_col_${index}`,
        componentId: `${comp.id}_col_${index}`,
        label: displayLabel,
        type: "column",
        parentType: "my-new-component",
        parentLabel: config.title || "새 컴포넌트",
        langKeyId: col.langKeyId,
        langKey: col.langKey,
      });
    });
  }
 }
 ```
 ---
 ## 7. 테이블명 추출 (테이블 사용 컴포넌트인 경우)
 ### 파일 위치
 `frontend/lib/utils/multilangLabelExtractor.ts`
 ### `extractTableNames` 함수에 추가
 컴포넌트가 테이블을 사용하는 경우, 테이블명을 추출해야 컬럼 라벨을 가져올 수 있습니다.
 ```typescript
 const extractTableNames = (comps: ComponentData[]): Set<string> => {
  const tableNames = new Set<string>();
  const processComponent = (comp: ComponentData) => {
    const config = comp.componentConfig;
    // 새 컴포넌트의 테이블명 추출
    if (comp.componentType === "my-new-component") {
      if (config?.tableName) {
        tableNames.add(config.tableName);
      }
      if (config?.selectedTable) {
        tableNames.add(config.selectedTable);
      }
    }
    // 자식 컴포넌트 재귀 처리
    if (comp.children && Array.isArray(comp.children)) {
      comp.children.forEach(processComponent);
    }
  };
  comps.forEach(processComponent);
  return tableNames;
 };
 ```
 ---
 ## 8. 체크리스트
 새 컴포넌트 개발 시 다음 항목을 확인하세요:
 ### 타입 정의
 - [ ] 모든 텍스트 속성에 `langKeyId`, `langKey` 필드 추가
 - [ ] 배열 속성(columns, tabs 등)의 각 항목에도 다국어 필드 추가
 ### 라벨 추출 (multilangLabelExtractor.ts)
 - [ ] `extractMultilangLabels` 함수에 라벨 추출 로직 추가
 - [ ] `extractTableNames` 함수에 테이블명 추출 로직 추가 (해당되는 경우)
 ### 매핑 적용 (multilangLabelExtractor.ts)
 - [ ] `applyMultilangMappings` 함수에 매핑 적용 로직 추가
 ### 번역 표시 (컴포넌트 파일)
 - [ ] `useScreenMultiLang` 훅 사용
 - [ ] `getTranslatedText`로 텍스트 번역 적용
 ### 키 수집 (ScreenMultiLangContext.tsx)
 - [ ] `collectLangKeys` 함수에 langKey 수집 로직 추가
 ### 설정 모달 (MultilangSettingsModal.tsx)
 - [ ] `extractLabelsFromComponents`에 라벨 표시 로직 추가
 ---
 ## 9. 관련 파일 목록
 | 파일                                                           | 역할                    |
 | -------------------------------------------------------------- | ----------------------- |
 | `frontend/lib/utils/multilangLabelExtractor.ts`                | 라벨 추출 및 매핑 적용  |
 | `frontend/contexts/ScreenMultiLangContext.tsx`                 | 번역 Context 및 키 수집 |
 | `frontend/components/screen/modals/MultilangSettingsModal.tsx` | 다국어 설정 UI          |
 | `frontend/components/screen/ScreenDesigner.tsx`                | 다국어 생성 버튼 처리   |
 | `backend-node/src/services/multilangService.ts`                | 다국어 키 생성 서비스   |
 ---
 ## 10. 주의사항
 1. **componentId 형식 일관성**: 라벨 추출과 매핑 적용에서 동일한 ID 형식 사용
   - 제목: `${comp.id}_title`
   - 컬럼: `${comp.id}_col_${index}`
   - 버튼: `${comp.id}_button`
 2. **중첩 구조 주의**: 분할패널처럼 중첩된 구조는 경로를 명확히 지정
   - `${comp.id}_left_title`, `${comp.id}_right_col_${index}`
 3. **기존 값 보존**: 매핑 적용 시 `updated.componentConfig`를 기반으로 업데이트
 4. **라벨 타입 구분**: 입력 폼의 `label`과 다른 컴포넌트의 `label`을 구분하여 처리
 5. **테스트**: 다국어 생성 → 다국어 설정 → 언어 변경 순서로 테스트
--- a/.cursor/rules/table-type-sql-guide.mdc
+++ b/.cursor/rules/table-type-sql-guide.mdc
@ -1,592 +0,0 @@
 # 테이블 타입 관리 SQL 작성 가이드
 테이블 타입 관리에서 테이블 생성 시 적용되는 컬럼, 타입, 메타데이터 등록 로직을 기반으로 한 SQL 작성 가이드입니다.
 ## 핵심 원칙
 1. **모든 비즈니스 컬럼은 `VARCHAR(500)`로 통일**: 날짜 타입 외 모든 컬럼은 `VARCHAR(500)`
 2. **날짜/시간 컬럼만 `TIMESTAMP` 사용**: `created_date`, `updated_date` 등
 3. **기본 컬럼 5개 자동 포함**: 모든 테이블에 id, created_date, updated_date, writer, company_code 필수
 4. **3개 메타데이터 테이블 등록 필수**: `table_labels`, `column_labels`, `table_type_columns`
 ---
 ## 1. 테이블 생성 DDL 템플릿
 ### 기본 구조
 ```sql
 CREATE TABLE "테이블명" (
  -- 시스템 기본 컬럼 (자동 포함)
  "id" varchar(500) PRIMARY KEY DEFAULT gen_random_uuid()::text,
  "created_date" timestamp DEFAULT now(),
  "updated_date" timestamp DEFAULT now(),
  "writer" varchar(500) DEFAULT NULL,
  "company_code" varchar(500),
  -- 사용자 정의 컬럼 (모두 VARCHAR(500))
  "컬럼1" varchar(500),
  "컬럼2" varchar(500),
  "컬럼3" varchar(500)
 );
 ```
 ### 예시: 고객 테이블 생성
 ```sql
 CREATE TABLE "customer_info" (
  "id" varchar(500) PRIMARY KEY DEFAULT gen_random_uuid()::text,
  "created_date" timestamp DEFAULT now(),
  "updated_date" timestamp DEFAULT now(),
  "writer" varchar(500) DEFAULT NULL,
  "company_code" varchar(500),
  "customer_name" varchar(500),
  "customer_code" varchar(500),
  "phone" varchar(500),
  "email" varchar(500),
  "address" varchar(500),
  "status" varchar(500),
  "registration_date" varchar(500)
 );
 ```
 ---
 ## 2. 메타데이터 테이블 등록
 테이블 생성 시 반드시 아래 3개 테이블에 메타데이터를 등록해야 합니다.
 ### 2.1 table_labels (테이블 메타데이터)
 ```sql
 INSERT INTO table_labels (table_name, table_label, description, created_date, updated_date)
 VALUES ('테이블명', '테이블 라벨', '테이블 설명', now(), now())
 ON CONFLICT (table_name)
 DO UPDATE SET
  table_label = EXCLUDED.table_label,
  description = EXCLUDED.description,
  updated_date = now();
 ```
 ### 2.2 table_type_columns (컬럼 타입 정보)
 **필수 컬럼**: `table_name`, `column_name`, `company_code`, `input_type`, `display_order`
 ```sql
 -- 기본 컬럼 등록 (display_order: -5 ~ -1)
 INSERT INTO table_type_columns (
  table_name, column_name, company_code, input_type, detail_settings,
  is_nullable, display_order, created_date, updated_date
 ) VALUES
  ('테이블명', 'id', '*', 'text', '{}', 'Y', -5, now(), now()),
  ('테이블명', 'created_date', '*', 'date', '{}', 'Y', -4, now(), now()),
  ('테이블명', 'updated_date', '*', 'date', '{}', 'Y', -3, now(), now()),
  ('테이블명', 'writer', '*', 'text', '{}', 'Y', -2, now(), now()),
  ('테이블명', 'company_code', '*', 'text', '{}', 'Y', -1, now(), now())
 ON CONFLICT (table_name, column_name, company_code)
 DO UPDATE SET
  input_type = EXCLUDED.input_type,
  display_order = EXCLUDED.display_order,
  updated_date = now();
 -- 사용자 정의 컬럼 등록 (display_order: 0부터 시작)
 INSERT INTO table_type_columns (
  table_name, column_name, company_code, input_type, detail_settings,
  is_nullable, display_order, created_date, updated_date
 ) VALUES
  ('테이블명', '컬럼1', '*', 'text', '{}', 'Y', 0, now(), now()),
  ('테이블명', '컬럼2', '*', 'number', '{}', 'Y', 1, now(), now()),
  ('테이블명', '컬럼3', '*', 'code', '{"codeCategory":"카테고리코드"}', 'Y', 2, now(), now())
 ON CONFLICT (table_name, column_name, company_code)
 DO UPDATE SET
  input_type = EXCLUDED.input_type,
  detail_settings = EXCLUDED.detail_settings,
  display_order = EXCLUDED.display_order,
  updated_date = now();
 ```
 ### 2.3 column_labels (레거시 호환용 - 필수)
 ```sql
 -- 기본 컬럼 등록
 INSERT INTO column_labels (
  table_name, column_name, column_label, input_type, detail_settings,
  description, display_order, is_visible, created_date, updated_date
 ) VALUES
  ('테이블명', 'id', 'ID', 'text', '{}', '기본키 (자동생성)', -5, true, now(), now()),
  ('테이블명', 'created_date', '생성일시', 'date', '{}', '레코드 생성일시', -4, true, now(), now()),
  ('테이블명', 'updated_date', '수정일시', 'date', '{}', '레코드 수정일시', -3, true, now(), now()),
  ('테이블명', 'writer', '작성자', 'text', '{}', '레코드 작성자', -2, true, now(), now()),
  ('테이블명', 'company_code', '회사코드', 'text', '{}', '회사 구분 코드', -1, true, now(), now())
 ON CONFLICT (table_name, column_name)
 DO UPDATE SET
  column_label = EXCLUDED.column_label,
  input_type = EXCLUDED.input_type,
  detail_settings = EXCLUDED.detail_settings,
  description = EXCLUDED.description,
  display_order = EXCLUDED.display_order,
  is_visible = EXCLUDED.is_visible,
  updated_date = now();
 -- 사용자 정의 컬럼 등록
 INSERT INTO column_labels (
  table_name, column_name, column_label, input_type, detail_settings,
  description, display_order, is_visible, created_date, updated_date
 ) VALUES
  ('테이블명', '컬럼1', '컬럼1 라벨', 'text', '{}', '컬럼1 설명', 0, true, now(), now()),
  ('테이블명', '컬럼2', '컬럼2 라벨', 'number', '{}', '컬럼2 설명', 1, true, now(), now())
 ON CONFLICT (table_name, column_name)
 DO UPDATE SET
  column_label = EXCLUDED.column_label,
  input_type = EXCLUDED.input_type,
  detail_settings = EXCLUDED.detail_settings,
  description = EXCLUDED.description,
  display_order = EXCLUDED.display_order,
  is_visible = EXCLUDED.is_visible,
  updated_date = now();
 ```
 ---
 ## 3. Input Type 정의
 ### 지원되는 Input Type 목록
 | input_type | 설명          | DB 저장 타입 | UI 컴포넌트          |
 | ---------- | ------------- | ------------ | -------------------- |
 | `text`     | 텍스트 입력   | VARCHAR(500) | Input                |
 | `number`   | 숫자 입력     | VARCHAR(500) | Input (type=number)  |
 | `date`     | 날짜/시간     | VARCHAR(500) | DatePicker           |
 | `code`     | 공통코드 선택 | VARCHAR(500) | Select (코드 목록)   |
 | `entity`   | 엔티티 참조   | VARCHAR(500) | Select (테이블 참조) |
 | `select`   | 선택 목록     | VARCHAR(500) | Select               |
 | `checkbox` | 체크박스      | VARCHAR(500) | Checkbox             |
 | `radio`    | 라디오 버튼   | VARCHAR(500) | RadioGroup           |
 | `textarea` | 긴 텍스트     | VARCHAR(500) | Textarea             |
 | `file`     | 파일 업로드   | VARCHAR(500) | FileUpload           |
 ### WebType → InputType 변환 규칙
 ```
 text, textarea, email, tel, url, password → text
 number, decimal → number
 date, datetime, time → date
 select, dropdown → select
 checkbox, boolean → checkbox
 radio → radio
 code → code
 entity → entity
 file → text
 button → text
 ```
 ---
 ## 4. Detail Settings 설정
 ### 4.1 Code 타입 (공통코드 참조)
 ```json
 {
  "codeCategory": "코드_카테고리_ID"
 }
 ```
 ```sql
 INSERT INTO table_type_columns (..., input_type, detail_settings, ...)
 VALUES (..., 'code', '{"codeCategory":"STATUS_CODE"}', ...);
 ```
 ### 4.2 Entity 타입 (테이블 참조)
 ```json
 {
  "referenceTable": "참조_테이블명",
  "referenceColumn": "참조_컬럼명(보통 id)",
  "displayColumn": "표시할_컬럼명"
 }
 ```
 ```sql
 INSERT INTO table_type_columns (..., input_type, detail_settings, ...)
 VALUES (..., 'entity', '{"referenceTable":"user_info","referenceColumn":"id","displayColumn":"user_name"}', ...);
 ```
 ### 4.3 Select 타입 (정적 옵션)
 ```json
 {
  "options": [
    { "label": "옵션1", "value": "value1" },
    { "label": "옵션2", "value": "value2" }
  ]
 }
 ```
 ---
 ## 5. 전체 예시: 주문 테이블 생성
 ### Step 1: DDL 실행
 ```sql
 CREATE TABLE "order_info" (
  "id" varchar(500) PRIMARY KEY DEFAULT gen_random_uuid()::text,
  "created_date" timestamp DEFAULT now(),
  "updated_date" timestamp DEFAULT now(),
  "writer" varchar(500) DEFAULT NULL,
  "company_code" varchar(500),
  "order_no" varchar(500),
  "order_date" varchar(500),
  "customer_id" varchar(500),
  "total_amount" varchar(500),
  "status" varchar(500),
  "notes" varchar(500)
 );
 ```
 ### Step 2: table_labels 등록
 ```sql
 INSERT INTO table_labels (table_name, table_label, description, created_date, updated_date)
 VALUES ('order_info', '주문 정보', '주문 관리 테이블', now(), now())
 ON CONFLICT (table_name)
 DO UPDATE SET
  table_label = EXCLUDED.table_label,
  description = EXCLUDED.description,
  updated_date = now();
 ```
 ### Step 3: table_type_columns 등록
 ```sql
 -- 기본 컬럼
 INSERT INTO table_type_columns (table_name, column_name, company_code, input_type, detail_settings, is_nullable, display_order, created_date, updated_date)
 VALUES
  ('order_info', 'id', '*', 'text', '{}', 'Y', -5, now(), now()),
  ('order_info', 'created_date', '*', 'date', '{}', 'Y', -4, now(), now()),
  ('order_info', 'updated_date', '*', 'date', '{}', 'Y', -3, now(), now()),
  ('order_info', 'writer', '*', 'text', '{}', 'Y', -2, now(), now()),
  ('order_info', 'company_code', '*', 'text', '{}', 'Y', -1, now(), now())
 ON CONFLICT (table_name, column_name, company_code) DO UPDATE SET input_type = EXCLUDED.input_type, display_order = EXCLUDED.display_order, updated_date = now();
 -- 사용자 정의 컬럼
 INSERT INTO table_type_columns (table_name, column_name, company_code, input_type, detail_settings, is_nullable, display_order, created_date, updated_date)
 VALUES
  ('order_info', 'order_no', '*', 'text', '{}', 'Y', 0, now(), now()),
  ('order_info', 'order_date', '*', 'date', '{}', 'Y', 1, now(), now()),
  ('order_info', 'customer_id', '*', 'entity', '{"referenceTable":"customer_info","referenceColumn":"id","displayColumn":"customer_name"}', 'Y', 2, now(), now()),
  ('order_info', 'total_amount', '*', 'number', '{}', 'Y', 3, now(), now()),
  ('order_info', 'status', '*', 'code', '{"codeCategory":"ORDER_STATUS"}', 'Y', 4, now(), now()),
  ('order_info', 'notes', '*', 'textarea', '{}', 'Y', 5, now(), now())
 ON CONFLICT (table_name, column_name, company_code) DO UPDATE SET input_type = EXCLUDED.input_type, detail_settings = EXCLUDED.detail_settings, display_order = EXCLUDED.display_order, updated_date = now();
 ```
 ### Step 4: column_labels 등록 (레거시 호환)
 ```sql
 -- 기본 컬럼
 INSERT INTO column_labels (table_name, column_name, column_label, input_type, detail_settings, description, display_order, is_visible, created_date, updated_date)
 VALUES
  ('order_info', 'id', 'ID', 'text', '{}', '기본키', -5, true, now(), now()),
  ('order_info', 'created_date', '생성일시', 'date', '{}', '레코드 생성일시', -4, true, now(), now()),
  ('order_info', 'updated_date', '수정일시', 'date', '{}', '레코드 수정일시', -3, true, now(), now()),
  ('order_info', 'writer', '작성자', 'text', '{}', '레코드 작성자', -2, true, now(), now()),
  ('order_info', 'company_code', '회사코드', 'text', '{}', '회사 구분 코드', -1, true, now(), now())
 ON CONFLICT (table_name, column_name) DO UPDATE SET column_label = EXCLUDED.column_label, input_type = EXCLUDED.input_type, updated_date = now();
 -- 사용자 정의 컬럼
 INSERT INTO column_labels (table_name, column_name, column_label, input_type, detail_settings, description, display_order, is_visible, created_date, updated_date)
 VALUES
  ('order_info', 'order_no', '주문번호', 'text', '{}', '주문 식별 번호', 0, true, now(), now()),
  ('order_info', 'order_date', '주문일자', 'date', '{}', '주문 발생 일자', 1, true, now(), now()),
  ('order_info', 'customer_id', '고객', 'entity', '{"referenceTable":"customer_info","referenceColumn":"id","displayColumn":"customer_name"}', '주문 고객', 2, true, now(), now()),
  ('order_info', 'total_amount', '총금액', 'number', '{}', '주문 총 금액', 3, true, now(), now()),
  ('order_info', 'status', '상태', 'code', '{"codeCategory":"ORDER_STATUS"}', '주문 상태', 4, true, now(), now()),
  ('order_info', 'notes', '비고', 'textarea', '{}', '추가 메모', 5, true, now(), now())
 ON CONFLICT (table_name, column_name) DO UPDATE SET column_label = EXCLUDED.column_label, input_type = EXCLUDED.input_type, detail_settings = EXCLUDED.detail_settings, description = EXCLUDED.description, display_order = EXCLUDED.display_order, updated_date = now();
 ```
 ---
 ## 6. 컬럼 추가 시
 ### DDL
 ```sql
 ALTER TABLE "테이블명" ADD COLUMN "새컬럼명" varchar(500);
 ```
 ### 메타데이터 등록
 ```sql
 -- table_type_columns
 INSERT INTO table_type_columns (table_name, column_name, company_code, input_type, detail_settings, is_nullable, display_order, created_date, updated_date)
 VALUES ('테이블명', '새컬럼명', '*', 'text', '{}', 'Y', (SELECT COALESCE(MAX(display_order), 0) + 1 FROM table_type_columns WHERE table_name = '테이블명'), now(), now())
 ON CONFLICT (table_name, column_name, company_code) DO UPDATE SET input_type = EXCLUDED.input_type, display_order = EXCLUDED.display_order, updated_date = now();
 -- column_labels
 INSERT INTO column_labels (table_name, column_name, column_label, input_type, detail_settings, description, display_order, is_visible, created_date, updated_date)
 VALUES ('테이블명', '새컬럼명', '새컬럼 라벨', 'text', '{}', '새컬럼 설명', (SELECT COALESCE(MAX(display_order), 0) + 1 FROM column_labels WHERE table_name = '테이블명'), true, now(), now())
 ON CONFLICT (table_name, column_name) DO UPDATE SET column_label = EXCLUDED.column_label, input_type = EXCLUDED.input_type, updated_date = now();
 ```
 ---
 ## 7. 로그 테이블 생성 (선택사항)
 변경 이력 추적이 필요한 테이블에는 로그 테이블을 생성할 수 있습니다.
 ### 7.1 로그 테이블 DDL 템플릿
 ```sql
 -- 로그 테이블 생성
 CREATE TABLE 테이블명_log (
  log_id SERIAL PRIMARY KEY,
  operation_type VARCHAR(10) NOT NULL,       -- INSERT/UPDATE/DELETE
  original_id VARCHAR(100),                   -- 원본 테이블 PK 값
  changed_column VARCHAR(100),                -- 변경된 컬럼명
  old_value TEXT,                             -- 변경 전 값
  new_value TEXT,                             -- 변경 후 값
  changed_by VARCHAR(50),                     -- 변경자 ID
  changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,  -- 변경 시각
  ip_address VARCHAR(50),                     -- 변경 요청 IP
  user_agent TEXT,                            -- User Agent
  full_row_before JSONB,                      -- 변경 전 전체 행
  full_row_after JSONB                        -- 변경 후 전체 행
 );
 -- 인덱스 생성
 CREATE INDEX idx_테이블명_log_original_id ON 테이블명_log(original_id);
 CREATE INDEX idx_테이블명_log_changed_at ON 테이블명_log(changed_at);
 CREATE INDEX idx_테이블명_log_operation ON 테이블명_log(operation_type);
 -- 코멘트 추가
 COMMENT ON TABLE 테이블명_log IS '테이블명 테이블 변경 이력';
 ```
 ### 7.2 트리거 함수 DDL 템플릿
 ```sql
 CREATE OR REPLACE FUNCTION 테이블명_log_trigger_func()
 RETURNS TRIGGER AS $$
 DECLARE
  v_column_name TEXT;
  v_old_value TEXT;
  v_new_value TEXT;
  v_user_id VARCHAR(50);
  v_ip_address VARCHAR(50);
 BEGIN
  v_user_id := current_setting('app.user_id', TRUE);
  v_ip_address := current_setting('app.ip_address', TRUE);
  IF (TG_OP = 'INSERT') THEN
    INSERT INTO 테이블명_log (operation_type, original_id, changed_by, ip_address, full_row_after)
    VALUES ('INSERT', NEW.id, v_user_id, v_ip_address, row_to_json(NEW)::jsonb);
    RETURN NEW;
  ELSIF (TG_OP = 'UPDATE') THEN
    FOR v_column_name IN
      SELECT column_name
      FROM information_schema.columns
      WHERE table_name = '테이블명'
        AND table_schema = 'public'
    LOOP
      EXECUTE format('SELECT ($1).%I::TEXT, ($2).%I::TEXT', v_column_name, v_column_name)
      INTO v_old_value, v_new_value
      USING OLD, NEW;
      IF v_old_value IS DISTINCT FROM v_new_value THEN
        INSERT INTO 테이블명_log (
          operation_type, original_id, changed_column, old_value, new_value,
          changed_by, ip_address, full_row_before, full_row_after
        )
        VALUES (
          'UPDATE', NEW.id, v_column_name, v_old_value, v_new_value,
          v_user_id, v_ip_address, row_to_json(OLD)::jsonb, row_to_json(NEW)::jsonb
        );
      END IF;
    END LOOP;
    RETURN NEW;
  ELSIF (TG_OP = 'DELETE') THEN
    INSERT INTO 테이블명_log (operation_type, original_id, changed_by, ip_address, full_row_before)
    VALUES ('DELETE', OLD.id, v_user_id, v_ip_address, row_to_json(OLD)::jsonb);
    RETURN OLD;
  END IF;
  RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 ```
 ### 7.3 트리거 DDL 템플릿
 ```sql
 CREATE TRIGGER 테이블명_audit_trigger
 AFTER INSERT OR UPDATE OR DELETE ON 테이블명
 FOR EACH ROW EXECUTE FUNCTION 테이블명_log_trigger_func();
 ```
 ### 7.4 로그 설정 등록
 ```sql
 INSERT INTO table_log_config (
  original_table_name, log_table_name, trigger_name,
  trigger_function_name, is_active, created_by, created_at
 ) VALUES (
  '테이블명', '테이블명_log', '테이블명_audit_trigger',
  '테이블명_log_trigger_func', 'Y', '생성자ID', now()
 );
 ```
 ### 7.5 table_labels에 use_log_table 플래그 설정
 ```sql
 UPDATE table_labels
 SET use_log_table = 'Y', updated_date = now()
 WHERE table_name = '테이블명';
 ```
 ### 7.6 전체 예시: order_info 로그 테이블 생성
 ```sql
 -- Step 1: 로그 테이블 생성
 CREATE TABLE order_info_log (
  log_id SERIAL PRIMARY KEY,
  operation_type VARCHAR(10) NOT NULL,
  original_id VARCHAR(100),
  changed_column VARCHAR(100),
  old_value TEXT,
  new_value TEXT,
  changed_by VARCHAR(50),
  changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  ip_address VARCHAR(50),
  user_agent TEXT,
  full_row_before JSONB,
  full_row_after JSONB
 );
 CREATE INDEX idx_order_info_log_original_id ON order_info_log(original_id);
 CREATE INDEX idx_order_info_log_changed_at ON order_info_log(changed_at);
 CREATE INDEX idx_order_info_log_operation ON order_info_log(operation_type);
 COMMENT ON TABLE order_info_log IS 'order_info 테이블 변경 이력';
 -- Step 2: 트리거 함수 생성
 CREATE OR REPLACE FUNCTION order_info_log_trigger_func()
 RETURNS TRIGGER AS $$
 DECLARE
  v_column_name TEXT;
  v_old_value TEXT;
  v_new_value TEXT;
  v_user_id VARCHAR(50);
  v_ip_address VARCHAR(50);
 BEGIN
  v_user_id := current_setting('app.user_id', TRUE);
  v_ip_address := current_setting('app.ip_address', TRUE);
  IF (TG_OP = 'INSERT') THEN
    INSERT INTO order_info_log (operation_type, original_id, changed_by, ip_address, full_row_after)
    VALUES ('INSERT', NEW.id, v_user_id, v_ip_address, row_to_json(NEW)::jsonb);
    RETURN NEW;
  ELSIF (TG_OP = 'UPDATE') THEN
    FOR v_column_name IN
      SELECT column_name FROM information_schema.columns
      WHERE table_name = 'order_info' AND table_schema = 'public'
    LOOP
      EXECUTE format('SELECT ($1).%I::TEXT, ($2).%I::TEXT', v_column_name, v_column_name)
      INTO v_old_value, v_new_value USING OLD, NEW;
      IF v_old_value IS DISTINCT FROM v_new_value THEN
        INSERT INTO order_info_log (operation_type, original_id, changed_column, old_value, new_value, changed_by, ip_address, full_row_before, full_row_after)
        VALUES ('UPDATE', NEW.id, v_column_name, v_old_value, v_new_value, v_user_id, v_ip_address, row_to_json(OLD)::jsonb, row_to_json(NEW)::jsonb);
      END IF;
    END LOOP;
    RETURN NEW;
  ELSIF (TG_OP = 'DELETE') THEN
    INSERT INTO order_info_log (operation_type, original_id, changed_by, ip_address, full_row_before)
    VALUES ('DELETE', OLD.id, v_user_id, v_ip_address, row_to_json(OLD)::jsonb);
    RETURN OLD;
  END IF;
  RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
 -- Step 3: 트리거 생성
 CREATE TRIGGER order_info_audit_trigger
 AFTER INSERT OR UPDATE OR DELETE ON order_info
 FOR EACH ROW EXECUTE FUNCTION order_info_log_trigger_func();
 -- Step 4: 로그 설정 등록
 INSERT INTO table_log_config (original_table_name, log_table_name, trigger_name, trigger_function_name, is_active, created_by, created_at)
 VALUES ('order_info', 'order_info_log', 'order_info_audit_trigger', 'order_info_log_trigger_func', 'Y', 'system', now());
 -- Step 5: table_labels 플래그 업데이트
 UPDATE table_labels SET use_log_table = 'Y', updated_date = now() WHERE table_name = 'order_info';
 ```
 ### 7.7 로그 테이블 삭제
 ```sql
 -- 트리거 삭제
 DROP TRIGGER IF EXISTS 테이블명_audit_trigger ON 테이블명;
 -- 트리거 함수 삭제
 DROP FUNCTION IF EXISTS 테이블명_log_trigger_func();
 -- 로그 테이블 삭제
 DROP TABLE IF EXISTS 테이블명_log;
 -- 로그 설정 삭제
 DELETE FROM table_log_config WHERE original_table_name = '테이블명';
 -- table_labels 플래그 업데이트
 UPDATE table_labels SET use_log_table = 'N', updated_date = now() WHERE table_name = '테이블명';
 ```
 ---
 ## 8. 체크리스트
 ### 테이블 생성/수정 시 반드시 확인할 사항:
 - [ ] DDL에 기본 5개 컬럼 포함 (id, created_date, updated_date, writer, company_code)
 - [ ] 모든 비즈니스 컬럼은 `VARCHAR(500)` 타입 사용
 - [ ] `table_labels`에 테이블 메타데이터 등록
 - [ ] `table_type_columns`에 모든 컬럼 등록 (company_code = '\*')
 - [ ] `column_labels`에 모든 컬럼 등록 (레거시 호환)
 - [ ] 기본 컬럼 display_order: -5 ~ -1
 - [ ] 사용자 정의 컬럼 display_order: 0부터 순차
 - [ ] code/entity 타입은 detail_settings에 참조 정보 포함
 - [ ] ON CONFLICT 절로 중복 시 UPDATE 처리
 ### 로그 테이블 생성 시 확인할 사항 (선택):
 - [ ] 로그 테이블 생성 (`테이블명_log`)
 - [ ] 인덱스 3개 생성 (original_id, changed_at, operation_type)
 - [ ] 트리거 함수 생성 (`테이블명_log_trigger_func`)
 - [ ] 트리거 생성 (`테이블명_audit_trigger`)
 - [ ] `table_log_config`에 로그 설정 등록
 - [ ] `table_labels.use_log_table = 'Y'` 업데이트
 ---
 ## 9. 금지 사항
 1. **DB 타입 직접 지정 금지**: NUMBER, INTEGER, DATE 등 DB 타입 직접 사용 금지
 2. **VARCHAR 길이 변경 금지**: 반드시 `VARCHAR(500)` 사용
 3. **기본 컬럼 누락 금지**: id, created_date, updated_date, writer, company_code 필수
 4. **메타데이터 미등록 금지**: 3개 테이블 모두 등록 필수
 5. **web_type 사용 금지**: 레거시 컬럼이므로 `input_type` 사용
 ---
 ## 참조 파일
 - `backend-node/src/services/ddlExecutionService.ts`: DDL 실행 서비스
 - `backend-node/src/services/tableManagementService.ts`: 로그 테이블 생성 서비스
 - `backend-node/src/types/ddl.ts`: DDL 타입 정의
 - `backend-node/src/controllers/ddlController.ts`: DDL API 컨트롤러
 - `backend-node/src/controllers/tableManagementController.ts`: 로그 테이블 API 컨트롤러
--- a/.playwright-mcp/pivotgrid-demo.png
+++ b/.playwright-mcp/pivotgrid-demo.png
--- a/.playwright-mcp/pivotgrid-table.png
+++ b/.playwright-mcp/pivotgrid-table.png
--- a/.playwright-mcp/pop-page-initial.png
+++ b/.playwright-mcp/pop-page-initial.png
--- a/PLAN.MD
+++ b/PLAN.MD
@ -1,72 +1,4 @@
-# 프로젝트: 화면 관리 기능 개선 (복제/삭제/그룹 관리/테이블 설정)
+# 프로젝트: 외부 REST API 커넥션 관리 확장 (POST/Body 지원)
 ## 개요
 화면 관리 시스템의 복제, 삭제, 수정, 테이블 설정 기능을 전면 개선하여 효율적인 화면 관리를 지원합니다.
 ## 핵심 기능
 ### 1. 단일 화면 복제
 - [x] 우클릭 컨텍스트 메뉴에서 "복제" 선택
 - [x] 화면명, 화면 코드 자동 생성 (중복 시 `_COPY` 접미사 추가)
 - [x] 연결된 모달 화면 함께 복제
 - [x] 대상 그룹 선택 가능
 - [x] 복제 후 목록 자동 새로고침
 ### 2. 그룹(폴더) 전체 복제
 - [x] 대분류 폴더 복제 시 모든 하위 폴더 + 화면 재귀적 복제
 - [x] 정렬 순서(display_order) 유지
 - [x] 대분류(최상위 그룹) 복제 시 경고 문구 표시
 - [x] 정렬 순서 입력 필드 추가
 - [x] 복제 모드 선택: 전체(폴더+화면), 폴더만, 화면만
 - [x] 모달 스크롤 지원 (max-h-[90vh] overflow-y-auto)
 ### 3. 고급 옵션: 이름 일괄 변경
 - [x] 찾을 텍스트 / 대체할 텍스트 (Find & Replace)
 - [x] 미리보기 기능
 ### 4. 삭제 기능
 - [x] 단일 화면 삭제 (휴지통으로 이동)
 - [x] 그룹 삭제 (화면 함께 삭제 옵션)
 - [x] 삭제 시 로딩 프로그레스 바 표시
 ### 5. 화면 수정 기능
 - [x] 우클릭 "수정" 메뉴로 화면 이름/그룹/역할/정렬 순서 변경
 - [x] 그룹 추가/수정 시 상위 그룹 기반 자동 회사 코드 설정
 ### 6. 테이블 설정 기능 (TableSettingModal)
 - [x] 화면 설정 모달에 "테이블 설정" 탭 추가
 - [x] 입력 타입 변경 시 관련 참조 필드 자동 초기화
  - 엔티티→텍스트: referenceTable, referenceColumn, displayColumn 초기화
  - 코드→다른 타입: codeCategory, codeValue 초기화
 - [x] 데이터 일관성 유지 (inputType ↔ referenceTable 연동)
 - [x] 조인 배지 단일화 (FK 배지 제거, 조인 배지만 표시)
 ### 7. 회사 코드 지원 (최고 관리자)
 - [x] 대상 회사 선택 가능
 - [x] 상위 그룹 선택 시 자동 회사 코드 설정
 ## 관련 파일
 - `frontend/components/screen/CopyScreenModal.tsx` - 복제 모달
 - `frontend/components/screen/ScreenGroupTreeView.tsx` - 트리 뷰 + 컨텍스트 메뉴
 - `frontend/components/screen/TableSettingModal.tsx` - 테이블 설정 모달
 - `frontend/components/screen/ScreenSettingModal.tsx` - 화면 설정 모달 (테이블 설정 탭 포함)
 - `frontend/lib/api/screen.ts` - 화면 API
 - `frontend/lib/api/screenGroup.ts` - 그룹 API
 - `frontend/lib/api/tableManagement.ts` - 테이블 관리 API
 ## 진행 상태
 - [완료] 단일 화면 복제 + 새로고침
 - [완료] 그룹 전체 복제 (재귀적)
 - [완료] 고급 옵션: 이름 일괄 변경 (Find & Replace)
 - [완료] 단일 화면/그룹 삭제 + 로딩 프로그레스
 - [완료] 화면 수정 (이름/그룹/역할/순서)
 - [완료] 테이블 설정 탭 추가
 - [완료] 입력 타입 변경 시 관련 필드 초기화
 - [완료] 그룹 복제 모달 스크롤 문제 수정
 ---
 # 이전 프로젝트: 외부 REST API 커넥션 관리 확장 (POST/Body 지원)
 ## 개요
 현재 GET 방식 위주로 구현된 외부 REST API 커넥션 관리 기능을 확장하여, POST, PUT, DELETE 등 다양한 HTTP 메서드와 JSON Request Body를 설정하고 테스트할 수 있도록 개선합니다. 이를 통해 토큰 발급 API나 데이터 전송 API 등 다양한 외부 시스템과의 연동을 지원합니다.
--- a/backend-node/package-lock.json
+++ b/backend-node/package-lock.json
@ -42,7 +42,6 @@
      },
      "devDependencies": {
        "@types/bcryptjs": "^2.4.6",
        "@types/bwip-js": "^3.2.3",
        "@types/compression": "^1.7.5",
        "@types/cors": "^2.8.17",
        "@types/express": "^4.17.21",
@ -1044,7 +1043,6 @@
      "integrity": "sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@babel/code-frame": "^7.27.1",
        "@babel/generator": "^7.28.3",
@ -2372,7 +2370,6 @@
      "resolved": "https://registry.npmjs.org/@redis/client/-/client-1.6.1.tgz",
      "integrity": "sha512-/KCsg3xSlR+nCK8/8ZYSknYxvXHwubJrU82F3Lm1Fp6789VQ0/3RJKfsmRXjqfaTA++23CvC3hqmqe/2GEt6Kw==",
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "cluster-key-slot": "1.1.2",
        "generic-pool": "3.9.0",
@ -3217,16 +3214,6 @@
        "@types/node": "*"
      }
    },
    "node_modules/@types/bwip-js": {
      "version": "3.2.3",
      "resolved": "https://registry.npmjs.org/@types/bwip-js/-/bwip-js-3.2.3.tgz",
      "integrity": "sha512-kgL1GOW7n5FhlC5aXnckaEim0rz1cFM4t9/xUwuNXCIDnWLx8ruQ4JQkG6znq4GQFovNLhQy5JdgbDwJw4D/zg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@types/node": "*"
      }
    },
    "node_modules/@types/compression": {
      "version": "1.8.1",
      "resolved": "https://registry.npmjs.org/@types/compression/-/compression-1.8.1.tgz",
@ -3476,7 +3463,6 @@
      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.17.tgz",
      "integrity": "sha512-gfehUI8N1z92kygssiuWvLiwcbOB3IRktR6hTDgJlXMYh5OvkPSRmgfoBUmfZt+vhwJtX7v1Yw4KvvAf7c5QKQ==",
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "undici-types": "~6.21.0"
      }
@ -3713,7 +3699,6 @@
      "integrity": "sha512-tbsV1jPne5CkFQCgPBcDOt30ItF7aJoZL997JSF7MhGQqOeT3svWRYxiqlfA5RUdlHN6Fi+EI9bxqbdyAUZjYQ==",
      "dev": true,
      "license": "BSD-2-Clause",
      "peer": true,
      "dependencies": {
        "@typescript-eslint/scope-manager": "6.21.0",
        "@typescript-eslint/types": "6.21.0",
@ -3931,7 +3916,6 @@
      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "bin": {
        "acorn": "bin/acorn"
      },
@ -4458,7 +4442,6 @@
        }
      ],
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "baseline-browser-mapping": "^2.8.3",
        "caniuse-lite": "^1.0.30001741",
@ -5669,7 +5652,6 @@
      "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@eslint-community/eslint-utils": "^4.2.0",
        "@eslint-community/regexpp": "^4.6.1",
@ -7432,7 +7414,6 @@
      "integrity": "sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@jest/core": "^29.7.0",
        "@jest/types": "^29.6.3",
@ -8402,6 +8383,7 @@
      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "js-tokens": "^3.0.0 || ^4.0.0"
      },
@ -9290,7 +9272,6 @@
      "resolved": "https://registry.npmjs.org/pg/-/pg-8.16.3.tgz",
      "integrity": "sha512-enxc1h0jA/aq5oSDMvqyW3q89ra6XIIDZgCX9vkMrnz5DFTw/Ny3Li2lFQ+pt3L6MCgm/5o2o8HW9hiJji+xvw==",
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "pg-connection-string": "^2.9.1",
        "pg-pool": "^3.10.1",
@ -10141,6 +10122,7 @@
      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "loose-envify": "^1.1.0"
      }
@ -10949,7 +10931,6 @@
      "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
      "dev": true,
      "license": "MIT",
      "peer": true,
      "dependencies": {
        "@cspotcode/source-map-support": "^0.8.0",
        "@tsconfig/node10": "^1.0.7",
@ -11055,7 +11036,6 @@
      "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
      "dev": true,
      "license": "Apache-2.0",
      "peer": true,
      "bin": {
        "tsc": "bin/tsc",
        "tsserver": "bin/tsserver"
--- a/backend-node/package.json
+++ b/backend-node/package.json
@ -56,7 +56,6 @@
  },
  "devDependencies": {
    "@types/bcryptjs": "^2.4.6",
    "@types/bwip-js": "^3.2.3",
    "@types/compression": "^1.7.5",
    "@types/cors": "^2.8.17",
    "@types/express": "^4.17.21",
--- a/backend-node/src/app.ts
+++ b/backend-node/src/app.ts
@ -58,7 +58,6 @@ import riskAlertRoutes from "./routes/riskAlertRoutes"; // 리스크/알림 관
 import todoRoutes from "./routes/todoRoutes"; // To-Do 관리
 import bookingRoutes from "./routes/bookingRoutes"; // 예약 요청 관리
 import mapDataRoutes from "./routes/mapDataRoutes"; // 지도 데이터 관리
 import excelMappingRoutes from "./routes/excelMappingRoutes"; // 엑셀 매핑 템플릿
 import yardLayoutRoutes from "./routes/yardLayoutRoutes"; // 3D 필드
 //import materialRoutes from "./routes/materialRoutes"; // 자재 관리
 import digitalTwinRoutes from "./routes/digitalTwinRoutes"; // 디지털 트윈 (야드 관제)
@ -73,7 +72,6 @@ import codeMergeRoutes from "./routes/codeMergeRoutes"; // 코드 병합
 import numberingRuleRoutes from "./routes/numberingRuleRoutes"; // 채번 규칙 관리
 import entitySearchRoutes from "./routes/entitySearchRoutes"; // 엔티티 검색
 import screenEmbeddingRoutes from "./routes/screenEmbeddingRoutes"; // 화면 임베딩 및 데이터 전달
 import screenGroupRoutes from "./routes/screenGroupRoutes"; // 화면 그룹 관리
 import vehicleTripRoutes from "./routes/vehicleTripRoutes"; // 차량 운행 이력 관리
 import driverRoutes from "./routes/driverRoutes"; // 공차중계 운전자 관리
 import taxInvoiceRoutes from "./routes/taxInvoiceRoutes"; // 세금계산서 관리
@ -198,7 +196,6 @@ app.use("/api/multilang", multilangRoutes);
 app.use("/api/table-management", tableManagementRoutes);
 app.use("/api/table-management", entityJoinRoutes); // 🎯 Entity 조인 기능
 app.use("/api/screen-management", screenManagementRoutes);
 app.use("/api/screen-groups", screenGroupRoutes); // 화면 그룹 관리
 app.use("/api/common-codes", commonCodeRoutes);
 app.use("/api/dynamic-form", dynamicFormRoutes);
 app.use("/api/files", fileRoutes);
@ -223,7 +220,6 @@ app.use("/api/external-rest-api-connections", externalRestApiConnectionRoutes);
 app.use("/api/multi-connection", multiConnectionRoutes);
 app.use("/api/screen-files", screenFileRoutes);
 app.use("/api/batch-configs", batchRoutes);
 app.use("/api/excel-mapping", excelMappingRoutes); // 엑셀 매핑 템플릿
 app.use("/api/batch-management", batchManagementRoutes);
 app.use("/api/batch-execution-logs", batchExecutionLogRoutes);
 // app.use("/api/db-type-categories", dbTypeCategoryRoutes); // 파일이 존재하지 않음
--- a/backend-node/src/controllers/adminController.ts
+++ b/backend-node/src/controllers/adminController.ts
@ -553,24 +553,10 @@ export const setUserLocale = async (
    const { locale } = req.body;
-    if (!locale) {
+    if (!locale || !["ko", "en", "ja", "zh"].includes(locale)) {
      res.status(400).json({
        success: false,
-        message: "로케일이 필요합니다.",
+        message: "유효하지 않은 로케일입니다. (ko, en, ja, zh 중 선택)",
      });
      return;
    }
    // language_master 테이블에서 유효한 언어 코드인지 확인
    const validLang = await queryOne<{ lang_code: string }>(
      "SELECT lang_code FROM language_master WHERE lang_code = $1 AND is_active = 'Y'",
      [locale]
    );
    if (!validLang) {
      res.status(400).json({
        success: false,
        message: `유효하지 않은 로케일입니다: ${locale}`,
      });
      return;
    }
@ -1179,33 +1165,6 @@ export async function saveMenu(
    logger.info("메뉴 저장 성공", { savedMenu });
    // 다국어 메뉴 카테고리 자동 생성
    try {
      const { MultiLangService } = await import("../services/multilangService");
      const multilangService = new MultiLangService();
      // 회사명 조회
      const companyInfo = await queryOne<{ company_name: string }>(
        `SELECT company_name FROM company_mng WHERE company_code = $1`,
        [companyCode]
      );
      const companyName = companyCode === "*" ? "공통" : (companyInfo?.company_name || companyCode);
      // 메뉴 경로 조회 및 카테고리 생성
      const menuPath = await multilangService.getMenuPath(savedMenu.objid.toString());
      await multilangService.ensureMenuCategory(companyCode, companyName, menuPath);
      logger.info("메뉴 다국어 카테고리 생성 완료", {
        menuObjId: savedMenu.objid.toString(),
        menuPath,
      });
    } catch (categoryError) {
      logger.warn("메뉴 다국어 카테고리 생성 실패 (메뉴 저장은 성공)", {
        menuObjId: savedMenu.objid.toString(),
        error: categoryError,
      });
    }
    const response: ApiResponse<any> = {
      success: true,
      message: "메뉴가 성공적으로 저장되었습니다.",
@ -1418,31 +1377,69 @@ export async function updateMenu(
 }
 /**
- * 재귀적으로 모든 하위 메뉴 ID를 수집하는 헬퍼 함수
+ * 메뉴 삭제
 */
-async function collectAllChildMenuIds(parentObjid: number): Promise<number[]> {
+export async function deleteMenu(
-  const allIds: number[] = [];
+  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  try {
    const { menuId } = req.params;
    logger.info(`메뉴 삭제 요청: menuId = ${menuId}`, { user: req.user });
-  // 직접 자식 메뉴들 조회
+    // 사용자의 company_code 확인
-  const children = await query<any>(
+    if (!req.user?.companyCode) {
-    `SELECT objid FROM menu_info WHERE parent_obj_id = $1`,
+      res.status(400).json({
-    [parentObjid]
+        success: false,
-  );
+        message: "사용자의 회사 코드를 찾을 수 없습니다.",
-  
+        error: "Missing company_code",
-  for (const child of children) {
+      });
-    allIds.push(child.objid);
+      return;
    // 자식의 자식들도 재귀적으로 수집
    const grandChildren = await collectAllChildMenuIds(child.objid);
    allIds.push(...grandChildren);
    }
-  return allIds;
+    const userCompanyCode = req.user.companyCode;
-}
+    const userType = req.user.userType;
    // 삭제하려는 메뉴 조회
    const currentMenu = await queryOne<any>(
      `SELECT objid, company_code FROM menu_info WHERE objid = $1`,
      [Number(menuId)]
    );
    if (!currentMenu) {
      res.status(404).json({
        success: false,
        message: `메뉴를 찾을 수 없습니다: ${menuId}`,
        error: "Menu not found",
      });
      return;
    }
    // 공통 메뉴(company_code = '*')는 최고 관리자만 삭제 가능
    if (currentMenu.company_code === "*") {
      if (userCompanyCode !== "*" || userType !== "SUPER_ADMIN") {
        res.status(403).json({
          success: false,
          message: "공통 메뉴는 최고 관리자만 삭제할 수 있습니다.",
          error: "Unauthorized to delete common menu",
        });
        return;
      }
    } else if (userCompanyCode !== "*") {
      // 회사 관리자는 자기 회사 메뉴만 삭제 가능
      if (currentMenu.company_code !== userCompanyCode) {
        res.status(403).json({
          success: false,
          message: "해당 회사의 메뉴를 삭제할 권한이 없습니다.",
          error: "Unauthorized to delete menu for this company",
        });
        return;
      }
    }
    // 외래키 제약 조건이 있는 관련 테이블 데이터 먼저 정리
    const menuObjid = Number(menuId);
 /**
 * 메뉴 및 관련 데이터 정리 헬퍼 함수
 */
 async function cleanupMenuRelatedData(menuObjid: number): Promise<void> {
    // 1. category_column_mapping에서 menu_objid를 NULL로 설정
    await query(
      `UPDATE category_column_mapping SET menu_objid = NULL WHERE menu_objid = $1`,
@ -1479,118 +1476,28 @@ async function cleanupMenuRelatedData(menuObjid: number): Promise<void> {
      [menuObjid]
    );
-  // 7. screen_groups에서 menu_objid를 NULL로 설정
+    logger.info("메뉴 관련 데이터 정리 완료", { menuObjid });
-  await query(
+
-    `UPDATE screen_groups SET menu_objid = NULL WHERE menu_objid = $1`,
+    // Raw Query를 사용한 메뉴 삭제
    const [deletedMenu] = await query<any>(
      `DELETE FROM menu_info WHERE objid = $1 RETURNING *`,
      [menuObjid]
    );
 }
-/**
+    logger.info("메뉴 삭제 성공", { deletedMenu });
 * 메뉴 삭제
 */
 export async function deleteMenu(
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  try {
    const { menuId } = req.params;
    logger.info(`메뉴 삭제 요청: menuId = ${menuId}`, { user: req.user });
    // 사용자의 company_code 확인
    if (!req.user?.companyCode) {
      res.status(400).json({
        success: false,
        message: "사용자의 회사 코드를 찾을 수 없습니다.",
        error: "Missing company_code",
      });
      return;
    }
    const userCompanyCode = req.user.companyCode;
    const userType = req.user.userType;
    // 삭제하려는 메뉴 조회
    const currentMenu = await queryOne<any>(
      `SELECT objid, company_code, menu_name_kor FROM menu_info WHERE objid = $1`,
      [Number(menuId)]
    );
    if (!currentMenu) {
      res.status(404).json({
        success: false,
        message: `메뉴를 찾을 수 없습니다: ${menuId}`,
        error: "Menu not found",
      });
      return;
    }
    // 공통 메뉴(company_code = '*')는 최고 관리자만 삭제 가능
    if (currentMenu.company_code === "*") {
      if (userCompanyCode !== "*" || userType !== "SUPER_ADMIN") {
        res.status(403).json({
          success: false,
          message: "공통 메뉴는 최고 관리자만 삭제할 수 있습니다.",
          error: "Unauthorized to delete common menu",
        });
        return;
      }
    } else if (userCompanyCode !== "*") {
      // 회사 관리자는 자기 회사 메뉴만 삭제 가능
      if (currentMenu.company_code !== userCompanyCode) {
        res.status(403).json({
          success: false,
          message: "해당 회사의 메뉴를 삭제할 권한이 없습니다.",
          error: "Unauthorized to delete menu for this company",
        });
        return;
      }
    }
    const menuObjid = Number(menuId);
    // 하위 메뉴들 재귀적으로 수집
    const childMenuIds = await collectAllChildMenuIds(menuObjid);
    const allMenuIdsToDelete = [menuObjid, ...childMenuIds];
    logger.info(`메뉴 삭제 대상: 본인(${menuObjid}) + 하위 메뉴 ${childMenuIds.length}개`, {
      menuName: currentMenu.menu_name_kor,
      totalCount: allMenuIdsToDelete.length,
      childMenuIds,
    });
    // 모든 삭제 대상 메뉴에 대해 관련 데이터 정리
    for (const objid of allMenuIdsToDelete) {
      await cleanupMenuRelatedData(objid);
    }
    logger.info("메뉴 관련 데이터 정리 완료", { 
      menuObjid, 
      totalCleaned: allMenuIdsToDelete.length 
    });
    // 하위 메뉴부터 역순으로 삭제 (외래키 제약 회피)
    // 가장 깊은 하위부터 삭제해야 하므로 역순으로
    const reversedIds = [...allMenuIdsToDelete].reverse();
    for (const objid of reversedIds) {
      await query(`DELETE FROM menu_info WHERE objid = $1`, [objid]);
    }
    logger.info("메뉴 삭제 성공", { 
      deletedMenuObjid: menuObjid,
      deletedMenuName: currentMenu.menu_name_kor,
      totalDeleted: allMenuIdsToDelete.length,
    });
    const response: ApiResponse<any> = {
      success: true,
-      message: `메뉴가 성공적으로 삭제되었습니다. (하위 메뉴 ${childMenuIds.length}개 포함)`,
+      message: "메뉴가 성공적으로 삭제되었습니다.",
      data: {
-        objid: menuObjid.toString(),
+        objid: deletedMenu.objid.toString(),
-        menuNameKor: currentMenu.menu_name_kor,
+        menuNameKor: deletedMenu.menu_name_kor,
-        deletedCount: allMenuIdsToDelete.length,
+        menuNameEng: deletedMenu.menu_name_eng,
-        deletedChildCount: childMenuIds.length,
+        menuUrl: deletedMenu.menu_url,
        menuDesc: deletedMenu.menu_desc,
        status: deletedMenu.status,
        writer: deletedMenu.writer,
        regdate: new Date(deletedMenu.regdate).toISOString(),
      },
    };
@ -1675,49 +1582,18 @@ export async function deleteMenusBatch(
      }
    }
    // 모든 삭제 대상 메뉴 ID 수집 (하위 메뉴 포함)
    const allMenuIdsToDelete = new Set<number>();
    for (const menuId of menuIds) {
      const objid = Number(menuId);
      allMenuIdsToDelete.add(objid);
      // 하위 메뉴들 재귀적으로 수집
      const childMenuIds = await collectAllChildMenuIds(objid);
      childMenuIds.forEach(id => allMenuIdsToDelete.add(Number(id)));
    }
    const allIdsArray = Array.from(allMenuIdsToDelete);
    logger.info(`메뉴 일괄 삭제 대상: 선택 ${menuIds.length}개 + 하위 메뉴 포함 총 ${allIdsArray.length}개`, {
      selectedMenuIds: menuIds,
      totalWithChildren: allIdsArray.length,
    });
    // 모든 삭제 대상 메뉴에 대해 관련 데이터 정리
    for (const objid of allIdsArray) {
      await cleanupMenuRelatedData(objid);
    }
    logger.info("메뉴 관련 데이터 정리 완료", { 
      totalCleaned: allIdsArray.length 
    });
    // Raw Query를 사용한 메뉴 일괄 삭제
    let deletedCount = 0;
    let failedCount = 0;
    const deletedMenus: any[] = [];
    const failedMenuIds: string[] = [];
    // 하위 메뉴부터 삭제하기 위해 역순으로 정렬
    const reversedIds = [...allIdsArray].reverse();
    // 각 메뉴 ID에 대해 삭제 시도
-    for (const menuObjid of reversedIds) {
+    for (const menuId of menuIds) {
      try {
        const result = await query<any>(
          `DELETE FROM menu_info WHERE objid = $1 RETURNING *`,
-          [menuObjid]
+          [Number(menuId)]
        );
        if (result.length > 0) {
@ -1728,20 +1604,20 @@ export async function deleteMenusBatch(
          });
        } else {
          failedCount++;
-          failedMenuIds.push(String(menuObjid));
+          failedMenuIds.push(menuId);
        }
      } catch (error) {
-        logger.error(`메뉴 삭제 실패 (ID: ${menuObjid}):`, error);
+        logger.error(`메뉴 삭제 실패 (ID: ${menuId}):`, error);
        failedCount++;
-        failedMenuIds.push(String(menuObjid));
+        failedMenuIds.push(menuId);
      }
    }
    logger.info("메뉴 일괄 삭제 완료", {
-      requested: menuIds.length,
+      total: menuIds.length,
      totalWithChildren: allIdsArray.length,
      deletedCount,
      failedCount,
      deletedMenus,
      failedMenuIds,
    });
@ -2773,24 +2649,6 @@ export const createCompany = async (
        });
      }
      // 다국어 카테고리 자동 생성
      try {
        const { MultiLangService } = await import("../services/multilangService");
        const multilangService = new MultiLangService();
        await multilangService.ensureCompanyCategory(
          createdCompany.company_code,
          createdCompany.company_name
        );
        logger.info("회사 다국어 카테고리 생성 완료", {
          companyCode: createdCompany.company_code,
        });
      } catch (categoryError) {
        logger.warn("회사 다국어 카테고리 생성 실패 (회사 등록은 성공)", {
          companyCode: createdCompany.company_code,
          error: categoryError,
        });
      }
      logger.info("회사 등록 성공", {
        companyCode: createdCompany.company_code,
        companyName: createdCompany.company_name,
@ -3200,23 +3058,6 @@ export const updateProfile = async (
    }
    if (locale !== undefined) {
      // language_master 테이블에서 유효한 언어 코드인지 확인
      const validLang = await queryOne<{ lang_code: string }>(
        "SELECT lang_code FROM language_master WHERE lang_code = $1 AND is_active = 'Y'",
        [locale]
      );
      if (!validLang) {
        res.status(400).json({
          result: false,
          error: {
            code: "INVALID_LOCALE",
            details: `유효하지 않은 로케일입니다: ${locale}`,
          },
        });
        return;
      }
      updateFields.push(`locale = $${paramIndex}`);
      updateValues.push(locale);
      paramIndex++;
--- a/backend-node/src/controllers/authController.ts
+++ b/backend-node/src/controllers/authController.ts
@ -141,110 +141,6 @@ export class AuthController {
    }
  }
  /**
   * POST /api/auth/switch-company
   * WACE 관리자 전용: 다른 회사로 전환
   */
  static async switchCompany(req: Request, res: Response): Promise<void> {
    try {
      const { companyCode } = req.body;
      const authHeader = req.get("Authorization");
      const token = authHeader && authHeader.split(" ")[1];
      if (!token) {
        res.status(401).json({
          success: false,
          message: "인증 토큰이 필요합니다.",
          error: { code: "TOKEN_MISSING" },
        });
        return;
      }
      // 현재 사용자 정보 확인
      const currentUser = JwtUtils.verifyToken(token);
      // WACE 관리자 권한 체크 (userType = "SUPER_ADMIN"만 확인)
      // 이미 다른 회사로 전환한 상태(companyCode != "*")에서도 다시 전환 가능해야 함
      if (currentUser.userType !== "SUPER_ADMIN") {
        logger.warn(`회사 전환 권한 없음: userId=${currentUser.userId}, userType=${currentUser.userType}, companyCode=${currentUser.companyCode}`);
        res.status(403).json({
          success: false,
          message: "회사 전환은 최고 관리자(SUPER_ADMIN)만 가능합니다.",
          error: { code: "FORBIDDEN" },
        });
        return;
      }
      // 전환할 회사 코드 검증
      if (!companyCode || companyCode.trim() === "") {
        res.status(400).json({
          success: false,
          message: "전환할 회사 코드가 필요합니다.",
          error: { code: "INVALID_INPUT" },
        });
        return;
      }
      logger.info(`=== WACE 관리자 회사 전환 ===`, {
        userId: currentUser.userId,
        originalCompanyCode: currentUser.companyCode,
        targetCompanyCode: companyCode,
      });
      // 회사 코드 존재 여부 확인 (company_code가 "*"가 아닌 경우만)
      if (companyCode !== "*") {
        const { query } = await import("../database/db");
        const companies = await query<any>(
          "SELECT company_code, company_name FROM company_mng WHERE company_code = $1",
          [companyCode]
        );
        if (companies.length === 0) {
          res.status(404).json({
            success: false,
            message: "존재하지 않는 회사 코드입니다.",
            error: { code: "COMPANY_NOT_FOUND" },
          });
          return;
        }
      }
      // 새로운 JWT 토큰 발급 (company_code만 변경)
      const newPersonBean: PersonBean = {
        ...currentUser,
        companyCode: companyCode.trim(), // 전환할 회사 코드로 변경
      };
      const newToken = JwtUtils.generateToken(newPersonBean);
      logger.info(`✅ 회사 전환 성공: ${currentUser.userId} → ${companyCode}`);
      res.status(200).json({
        success: true,
        message: "회사 전환 완료",
        data: {
          token: newToken,
          companyCode: companyCode.trim(),
        },
      });
    } catch (error) {
      logger.error(
        `회사 전환 API 오류: ${error instanceof Error ? error.message : error}`
      );
      res.status(500).json({
        success: false,
        message: "회사 전환 중 오류가 발생했습니다.",
        error: {
          code: "SERVER_ERROR",
          details:
            error instanceof Error
              ? error.message
              : "알 수 없는 오류가 발생했습니다.",
        },
      });
    }
  }
  /**
   * POST /api/auth/logout
   * 기존 Java ApiLoginController.logout() 메서드 포팅
@ -330,14 +226,13 @@ export class AuthController {
      }
      // 프론트엔드 호환성을 위해 더 많은 사용자 정보 반환
      // ⚠️ JWT 토큰의 companyCode를 우선 사용 (회사 전환 기능 지원)
      const userInfoResponse: any = {
        userId: dbUserInfo.userId,
        userName: dbUserInfo.userName || "",
        deptName: dbUserInfo.deptName || "",
-        companyCode: userInfo.companyCode || dbUserInfo.companyCode || "ILSHIN", // JWT 토큰 우선
+        companyCode: dbUserInfo.companyCode || "ILSHIN",
-        company_code: userInfo.companyCode || dbUserInfo.companyCode || "ILSHIN", // JWT 토큰 우선
+        company_code: dbUserInfo.companyCode || "ILSHIN", // 프론트엔드 호환성
-        userType: userInfo.userType || dbUserInfo.userType || "USER", // JWT 토큰 우선
+        userType: dbUserInfo.userType || "USER",
        userTypeName: dbUserInfo.userTypeName || "일반사용자",
        email: dbUserInfo.email || "",
        photo: dbUserInfo.photo,
--- a/backend-node/src/controllers/codeMergeController.ts
+++ b/backend-node/src/controllers/codeMergeController.ts
@ -282,175 +282,3 @@ export async function previewCodeMerge(
  }
 }
 /**
 * 값 기반 코드 병합 - 모든 테이블의 모든 컬럼에서 해당 값을 찾아 변경
 * 컬럼명에 상관없이 oldValue를 가진 모든 곳을 newValue로 변경
 */
 export async function mergeCodeByValue(
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  const { oldValue, newValue } = req.body;
  const companyCode = req.user?.companyCode;
  try {
    // 입력값 검증
    if (!oldValue || !newValue) {
      res.status(400).json({
        success: false,
        message: "필수 필드가 누락되었습니다. (oldValue, newValue)",
      });
      return;
    }
    if (!companyCode) {
      res.status(401).json({
        success: false,
        message: "인증 정보가 없습니다.",
      });
      return;
    }
    // 같은 값으로 병합 시도 방지
    if (oldValue === newValue) {
      res.status(400).json({
        success: false,
        message: "기존 값과 새 값이 동일합니다.",
      });
      return;
    }
    logger.info("값 기반 코드 병합 시작", {
      oldValue,
      newValue,
      companyCode,
      userId: req.user?.userId,
    });
    // PostgreSQL 함수 호출
    const result = await pool.query(
      "SELECT * FROM merge_code_by_value($1, $2, $3)",
      [oldValue, newValue, companyCode]
    );
    // 결과 처리
    const affectedData = Array.isArray(result) ? result : ((result as any).rows || []);
    const totalRows = affectedData.reduce(
      (sum: number, row: any) => sum + parseInt(row.out_rows_updated || 0),
      0
    );
    logger.info("값 기반 코드 병합 완료", {
      oldValue,
      newValue,
      affectedTablesCount: affectedData.length,
      totalRowsUpdated: totalRows,
    });
    res.json({
      success: true,
      message: `코드 병합 완료: ${oldValue} → ${newValue}`,
      data: {
        oldValue,
        newValue,
        affectedData: affectedData.map((row: any) => ({
          tableName: row.out_table_name,
          columnName: row.out_column_name,
          rowsUpdated: parseInt(row.out_rows_updated),
        })),
        totalRowsUpdated: totalRows,
      },
    });
  } catch (error: any) {
    logger.error("값 기반 코드 병합 실패:", {
      error: error.message,
      stack: error.stack,
      oldValue,
      newValue,
    });
    res.status(500).json({
      success: false,
      message: "코드 병합 중 오류가 발생했습니다.",
      error: {
        code: "CODE_MERGE_BY_VALUE_ERROR",
        details: error.message,
      },
    });
  }
 }
 /**
 * 값 기반 코드 병합 미리보기
 * 컬럼명에 상관없이 해당 값을 가진 모든 테이블/컬럼 조회
 */
 export async function previewMergeCodeByValue(
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  const { oldValue } = req.body;
  const companyCode = req.user?.companyCode;
  try {
    if (!oldValue) {
      res.status(400).json({
        success: false,
        message: "필수 필드가 누락되었습니다. (oldValue)",
      });
      return;
    }
    if (!companyCode) {
      res.status(401).json({
        success: false,
        message: "인증 정보가 없습니다.",
      });
      return;
    }
    logger.info("값 기반 코드 병합 미리보기", { oldValue, companyCode });
    // PostgreSQL 함수 호출
    const result = await pool.query(
      "SELECT * FROM preview_merge_code_by_value($1, $2)",
      [oldValue, companyCode]
    );
    const preview = Array.isArray(result) ? result : ((result as any).rows || []);
    const totalRows = preview.reduce(
      (sum: number, row: any) => sum + parseInt(row.out_affected_rows || 0),
      0
    );
    logger.info("값 기반 코드 병합 미리보기 완료", {
      tablesCount: preview.length,
      totalRows,
    });
    res.json({
      success: true,
      message: "코드 병합 미리보기 완료",
      data: {
        oldValue,
        preview: preview.map((row: any) => ({
          tableName: row.out_table_name,
          columnName: row.out_column_name,
          affectedRows: parseInt(row.out_affected_rows),
        })),
        totalAffectedRows: totalRows,
      },
    });
  } catch (error: any) {
    logger.error("값 기반 코드 병합 미리보기 실패:", error);
    res.status(500).json({
      success: false,
      message: "코드 병합 미리보기 중 오류가 발생했습니다.",
      error: {
        code: "PREVIEW_BY_VALUE_ERROR",
        details: error.message,
      },
    });
  }
 }
--- a/backend-node/src/controllers/dynamicFormController.ts
+++ b/backend-node/src/controllers/dynamicFormController.ts
@ -231,7 +231,7 @@ export const deleteFormData = async (
  try {
    const { id } = req.params;
    const { companyCode, userId } = req.user as any;
-    const { tableName, screenId } = req.body;
+    const { tableName } = req.body;
    if (!tableName) {
      return res.status(400).json({
@ -240,16 +240,7 @@ export const deleteFormData = async (
      });
    }
-    // screenId를 숫자로 변환 (문자열로 전달될 수 있음)
+    await dynamicFormService.deleteFormData(id, tableName, companyCode, userId); // userId 추가
    const parsedScreenId = screenId ? parseInt(screenId, 10) : undefined;
    await dynamicFormService.deleteFormData(
      id,
      tableName,
      companyCode,
      userId,
      parsedScreenId // screenId 추가 (제어관리 실행용)
    );
    res.json({
      success: true,
--- a/backend-node/src/controllers/entityJoinController.ts
+++ b/backend-node/src/controllers/entityJoinController.ts
@ -66,23 +66,11 @@ export class EntityJoinController {
            const userField = parsedAutoFilter.userField || "companyCode";
            const userValue = ((req as any).user as any)[userField];
-            // 🆕 프리뷰용 회사 코드 오버라이드 (최고 관리자만 허용)
+            if (userValue) {
-            let finalCompanyCode = userValue;
+              searchConditions[filterColumn] = userValue;
            if (parsedAutoFilter.companyCodeOverride && userValue === "*") {
              // 최고 관리자만 다른 회사 코드로 오버라이드 가능
              finalCompanyCode = parsedAutoFilter.companyCodeOverride;
              logger.info("🔓 최고 관리자 회사 코드 오버라이드:", {
                originalCompanyCode: userValue,
                overrideCompanyCode: parsedAutoFilter.companyCodeOverride,
                tableName,
              });
            }
            if (finalCompanyCode) {
              searchConditions[filterColumn] = finalCompanyCode;
              logger.info("🔒 Entity 조인에 멀티테넌시 필터 적용:", {
                filterColumn,
-                finalCompanyCode,
+                userValue,
                tableName,
              });
            }
--- a/backend-node/src/controllers/entitySearchController.ts
+++ b/backend-node/src/controllers/entitySearchController.ts
@ -107,88 +107,14 @@ export async function searchEntity(req: AuthenticatedRequest, res: Response) {
    }
    // 추가 필터 조건 (존재하는 컬럼만)
    // 지원 연산자: =, !=, >, <, >=, <=, in, notIn, like
    // 특수 키 형식: column__operator (예: division__in, name__like)
    const additionalFilter = JSON.parse(filterCondition as string);
    for (const [key, value] of Object.entries(additionalFilter)) {
-      // 특수 키 형식 파싱: column__operator
+      if (existingColumns.has(key)) {
-      let columnName = key;
+        whereConditions.push(`${key} = $${paramIndex}`);
      let operator = "=";
      if (key.includes("__")) {
        const parts = key.split("__");
        columnName = parts[0];
        operator = parts[1] || "=";
      }
      if (!existingColumns.has(columnName)) {
        logger.warn("엔티티 검색: 필터 조건에 존재하지 않는 컬럼 제외", { tableName, key, columnName });
        continue;
      }
      // 연산자별 WHERE 조건 생성
      switch (operator) {
        case "=":
          whereConditions.push(`"${columnName}" = $${paramIndex}`);
        params.push(value);
        paramIndex++;
-          break;
+      } else {
-        case "!=":
+        logger.warn("엔티티 검색: 필터 조건에 존재하지 않는 컬럼 제외", { tableName, key });
          whereConditions.push(`"${columnName}" != $${paramIndex}`);
          params.push(value);
          paramIndex++;
          break;
        case ">":
          whereConditions.push(`"${columnName}" > $${paramIndex}`);
          params.push(value);
          paramIndex++;
          break;
        case "<":
          whereConditions.push(`"${columnName}" < $${paramIndex}`);
          params.push(value);
          paramIndex++;
          break;
        case ">=":
          whereConditions.push(`"${columnName}" >= $${paramIndex}`);
          params.push(value);
          paramIndex++;
          break;
        case "<=":
          whereConditions.push(`"${columnName}" <= $${paramIndex}`);
          params.push(value);
          paramIndex++;
          break;
        case "in":
          // IN 연산자: 값이 배열이거나 쉼표로 구분된 문자열
          const inValues = Array.isArray(value) ? value : String(value).split(",").map(v => v.trim());
          if (inValues.length > 0) {
            const placeholders = inValues.map((_, i) => `$${paramIndex + i}`).join(", ");
            whereConditions.push(`"${columnName}" IN (${placeholders})`);
            params.push(...inValues);
            paramIndex += inValues.length;
          }
          break;
        case "notIn":
          // NOT IN 연산자
          const notInValues = Array.isArray(value) ? value : String(value).split(",").map(v => v.trim());
          if (notInValues.length > 0) {
            const placeholders = notInValues.map((_, i) => `$${paramIndex + i}`).join(", ");
            whereConditions.push(`"${columnName}" NOT IN (${placeholders})`);
            params.push(...notInValues);
            paramIndex += notInValues.length;
          }
          break;
        case "like":
          whereConditions.push(`"${columnName}"::text ILIKE $${paramIndex}`);
          params.push(`%${value}%`);
          paramIndex++;
          break;
        default:
          // 알 수 없는 연산자는 등호로 처리
          whereConditions.push(`"${columnName}" = $${paramIndex}`);
          params.push(value);
          paramIndex++;
          break;
      }
    }
--- a/backend-node/src/controllers/excelMappingController.ts
+++ b/backend-node/src/controllers/excelMappingController.ts
@ -1,208 +0,0 @@
 import { Response } from "express";
 import { AuthenticatedRequest } from "../middleware/authMiddleware";
 import excelMappingService from "../services/excelMappingService";
 import { logger } from "../utils/logger";
 /**
 * 엑셀 컬럼 구조로 매핑 템플릿 조회
 * POST /api/excel-mapping/find
 */
 export async function findMappingByColumns(
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  try {
    const { tableName, excelColumns } = req.body;
    const companyCode = req.user?.companyCode || "*";
    if (!tableName || !excelColumns || !Array.isArray(excelColumns)) {
      res.status(400).json({
        success: false,
        message: "tableName과 excelColumns(배열)가 필요합니다.",
      });
      return;
    }
    logger.info("엑셀 매핑 템플릿 조회 요청", {
      tableName,
      excelColumns,
      companyCode,
      userId: req.user?.userId,
    });
    const template = await excelMappingService.findMappingByColumns(
      tableName,
      excelColumns,
      companyCode
    );
    if (template) {
      res.json({
        success: true,
        data: template,
        message: "기존 매핑 템플릿을 찾았습니다.",
      });
    } else {
      res.json({
        success: true,
        data: null,
        message: "일치하는 매핑 템플릿이 없습니다.",
      });
    }
  } catch (error: any) {
    logger.error("매핑 템플릿 조회 실패", { error: error.message });
    res.status(500).json({
      success: false,
      message: "매핑 템플릿 조회 중 오류가 발생했습니다.",
      error: error.message,
    });
  }
 }
 /**
 * 매핑 템플릿 저장 (UPSERT)
 * POST /api/excel-mapping/save
 */
 export async function saveMappingTemplate(
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  try {
    const { tableName, excelColumns, columnMappings } = req.body;
    const companyCode = req.user?.companyCode || "*";
    const userId = req.user?.userId;
    if (!tableName || !excelColumns || !columnMappings) {
      res.status(400).json({
        success: false,
        message: "tableName, excelColumns, columnMappings가 필요합니다.",
      });
      return;
    }
    logger.info("엑셀 매핑 템플릿 저장 요청", {
      tableName,
      excelColumns,
      columnMappings,
      companyCode,
      userId,
    });
    const template = await excelMappingService.saveMappingTemplate(
      tableName,
      excelColumns,
      columnMappings,
      companyCode,
      userId
    );
    res.json({
      success: true,
      data: template,
      message: "매핑 템플릿이 저장되었습니다.",
    });
  } catch (error: any) {
    logger.error("매핑 템플릿 저장 실패", { error: error.message });
    res.status(500).json({
      success: false,
      message: "매핑 템플릿 저장 중 오류가 발생했습니다.",
      error: error.message,
    });
  }
 }
 /**
 * 테이블의 매핑 템플릿 목록 조회
 * GET /api/excel-mapping/list/:tableName
 */
 export async function getMappingTemplates(
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  try {
    const { tableName } = req.params;
    const companyCode = req.user?.companyCode || "*";
    if (!tableName) {
      res.status(400).json({
        success: false,
        message: "tableName이 필요합니다.",
      });
      return;
    }
    logger.info("매핑 템플릿 목록 조회 요청", {
      tableName,
      companyCode,
    });
    const templates = await excelMappingService.getMappingTemplates(
      tableName,
      companyCode
    );
    res.json({
      success: true,
      data: templates,
    });
  } catch (error: any) {
    logger.error("매핑 템플릿 목록 조회 실패", { error: error.message });
    res.status(500).json({
      success: false,
      message: "매핑 템플릿 목록 조회 중 오류가 발생했습니다.",
      error: error.message,
    });
  }
 }
 /**
 * 매핑 템플릿 삭제
 * DELETE /api/excel-mapping/:id
 */
 export async function deleteMappingTemplate(
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  try {
    const { id } = req.params;
    const companyCode = req.user?.companyCode || "*";
    if (!id) {
      res.status(400).json({
        success: false,
        message: "id가 필요합니다.",
      });
      return;
    }
    logger.info("매핑 템플릿 삭제 요청", {
      id,
      companyCode,
    });
    const deleted = await excelMappingService.deleteMappingTemplate(
      parseInt(id),
      companyCode
    );
    if (deleted) {
      res.json({
        success: true,
        message: "매핑 템플릿이 삭제되었습니다.",
      });
    } else {
      res.status(404).json({
        success: false,
        message: "삭제할 매핑 템플릿을 찾을 수 없습니다.",
      });
    }
  } catch (error: any) {
    logger.error("매핑 템플릿 삭제 실패", { error: error.message });
    res.status(500).json({
      success: false,
      message: "매핑 템플릿 삭제 중 오류가 발생했습니다.",
      error: error.message,
    });
  }
 }
--- a/backend-node/src/controllers/multilangController.ts
+++ b/backend-node/src/controllers/multilangController.ts
@ -10,10 +10,7 @@ import {
  SaveLangTextsRequest,
  GetUserTextParams,
  BatchTranslationRequest,
  GenerateKeyRequest,
  CreateOverrideKeyRequest,
  ApiResponse,
  LangCategory,
 } from "../types/multilang";
 /**
@ -190,7 +187,7 @@ export const getLangKeys = async (
  res: Response
 ): Promise<void> => {
  try {
-    const { companyCode, menuCode, keyType, searchText, categoryId } = req.query;
+    const { companyCode, menuCode, keyType, searchText } = req.query;
    logger.info("다국어 키 목록 조회 요청", {
      query: req.query,
      user: req.user,
@ -202,7 +199,6 @@ export const getLangKeys = async (
      menuCode: menuCode as string,
      keyType: keyType as string,
      searchText: searchText as string,
      categoryId: categoryId ? parseInt(categoryId as string, 10) : undefined,
    });
    const response: ApiResponse<any[]> = {
@ -634,391 +630,6 @@ export const deleteLanguage = async (
  }
 };
 // =====================================================
 // 카테고리 관련 API
 // =====================================================
 /**
 * GET /api/multilang/categories
 * 카테고리 목록 조회 API (트리 구조)
 */
 export const getCategories = async (
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> => {
  try {
    logger.info("카테고리 목록 조회 요청", { user: req.user });
    const multiLangService = new MultiLangService();
    const categories = await multiLangService.getCategories();
    const response: ApiResponse<LangCategory[]> = {
      success: true,
      message: "카테고리 목록 조회 성공",
      data: categories,
    };
    res.status(200).json(response);
  } catch (error) {
    logger.error("카테고리 목록 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "카테고리 목록 조회 중 오류가 발생했습니다.",
      error: {
        code: "CATEGORY_LIST_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    });
  }
 };
 /**
 * GET /api/multilang/categories/:categoryId
 * 카테고리 상세 조회 API
 */
 export const getCategoryById = async (
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> => {
  try {
    const { categoryId } = req.params;
    logger.info("카테고리 상세 조회 요청", { categoryId, user: req.user });
    const multiLangService = new MultiLangService();
    const category = await multiLangService.getCategoryById(parseInt(categoryId));
    if (!category) {
      res.status(404).json({
        success: false,
        message: "카테고리를 찾을 수 없습니다.",
        error: {
          code: "CATEGORY_NOT_FOUND",
          details: `Category ID ${categoryId} not found`,
        },
      });
      return;
    }
    const response: ApiResponse<LangCategory> = {
      success: true,
      message: "카테고리 상세 조회 성공",
      data: category,
    };
    res.status(200).json(response);
  } catch (error) {
    logger.error("카테고리 상세 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "카테고리 상세 조회 중 오류가 발생했습니다.",
      error: {
        code: "CATEGORY_DETAIL_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    });
  }
 };
 /**
 * GET /api/multilang/categories/:categoryId/path
 * 카테고리 경로 조회 API (부모 포함)
 */
 export const getCategoryPath = async (
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> => {
  try {
    const { categoryId } = req.params;
    logger.info("카테고리 경로 조회 요청", { categoryId, user: req.user });
    const multiLangService = new MultiLangService();
    const path = await multiLangService.getCategoryPath(parseInt(categoryId));
    const response: ApiResponse<LangCategory[]> = {
      success: true,
      message: "카테고리 경로 조회 성공",
      data: path,
    };
    res.status(200).json(response);
  } catch (error) {
    logger.error("카테고리 경로 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "카테고리 경로 조회 중 오류가 발생했습니다.",
      error: {
        code: "CATEGORY_PATH_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    });
  }
 };
 // =====================================================
 // 자동 생성 및 오버라이드 관련 API
 // =====================================================
 /**
 * POST /api/multilang/keys/generate
 * 키 자동 생성 API
 */
 export const generateKey = async (
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> => {
  try {
    const generateData: GenerateKeyRequest = req.body;
    logger.info("키 자동 생성 요청", { generateData, user: req.user });
    // 필수 입력값 검증
    if (!generateData.companyCode || !generateData.categoryId || !generateData.keyMeaning) {
      res.status(400).json({
        success: false,
        message: "회사 코드, 카테고리 ID, 키 의미는 필수입니다.",
        error: {
          code: "MISSING_REQUIRED_FIELDS",
          details: "companyCode, categoryId, and keyMeaning are required",
        },
      });
      return;
    }
    // 권한 검사: 공통 키(*)는 최고 관리자만 생성 가능
    if (generateData.companyCode === "*" && req.user?.companyCode !== "*") {
      res.status(403).json({
        success: false,
        message: "공통 키는 최고 관리자만 생성할 수 있습니다.",
        error: {
          code: "PERMISSION_DENIED",
          details: "Only super admin can create common keys",
        },
      });
      return;
    }
    // 회사 관리자는 자기 회사 키만 생성 가능
    if (generateData.companyCode !== "*" && 
        req.user?.companyCode !== "*" && 
        generateData.companyCode !== req.user?.companyCode) {
      res.status(403).json({
        success: false,
        message: "다른 회사의 키를 생성할 권한이 없습니다.",
        error: {
          code: "PERMISSION_DENIED",
          details: "Cannot create keys for other companies",
        },
      });
      return;
    }
    const multiLangService = new MultiLangService();
    const keyId = await multiLangService.generateKey({
      ...generateData,
      createdBy: req.user?.userId || "system",
    });
    const response: ApiResponse<number> = {
      success: true,
      message: "키가 성공적으로 생성되었습니다.",
      data: keyId,
    };
    res.status(201).json(response);
  } catch (error) {
    logger.error("키 자동 생성 실패:", error);
    res.status(500).json({
      success: false,
      message: "키 자동 생성 중 오류가 발생했습니다.",
      error: {
        code: "KEY_GENERATE_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    });
  }
 };
 /**
 * POST /api/multilang/keys/preview
 * 키 미리보기 API
 */
 export const previewKey = async (
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> => {
  try {
    const { categoryId, keyMeaning, companyCode } = req.body;
    logger.info("키 미리보기 요청", { categoryId, keyMeaning, companyCode, user: req.user });
    if (!categoryId || !keyMeaning || !companyCode) {
      res.status(400).json({
        success: false,
        message: "카테고리 ID, 키 의미, 회사 코드는 필수입니다.",
        error: {
          code: "MISSING_REQUIRED_FIELDS",
          details: "categoryId, keyMeaning, and companyCode are required",
        },
      });
      return;
    }
    const multiLangService = new MultiLangService();
    const preview = await multiLangService.previewGeneratedKey(
      parseInt(categoryId),
      keyMeaning,
      companyCode
    );
    const response: ApiResponse<{
      langKey: string;
      exists: boolean;
      isOverride: boolean;
      baseKeyId?: number;
    }> = {
      success: true,
      message: "키 미리보기 성공",
      data: preview,
    };
    res.status(200).json(response);
  } catch (error) {
    logger.error("키 미리보기 실패:", error);
    res.status(500).json({
      success: false,
      message: "키 미리보기 중 오류가 발생했습니다.",
      error: {
        code: "KEY_PREVIEW_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    });
  }
 };
 /**
 * POST /api/multilang/keys/override
 * 오버라이드 키 생성 API
 */
 export const createOverrideKey = async (
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> => {
  try {
    const overrideData: CreateOverrideKeyRequest = req.body;
    logger.info("오버라이드 키 생성 요청", { overrideData, user: req.user });
    // 필수 입력값 검증
    if (!overrideData.companyCode || !overrideData.baseKeyId) {
      res.status(400).json({
        success: false,
        message: "회사 코드와 원본 키 ID는 필수입니다.",
        error: {
          code: "MISSING_REQUIRED_FIELDS",
          details: "companyCode and baseKeyId are required",
        },
      });
      return;
    }
    // 최고 관리자(*)는 오버라이드 키를 만들 수 없음 (이미 공통 키)
    if (overrideData.companyCode === "*") {
      res.status(400).json({
        success: false,
        message: "공통 키에 대한 오버라이드는 생성할 수 없습니다.",
        error: {
          code: "INVALID_OVERRIDE",
          details: "Cannot create override for common keys",
        },
      });
      return;
    }
    // 회사 관리자는 자기 회사 오버라이드만 생성 가능
    if (req.user?.companyCode !== "*" && 
        overrideData.companyCode !== req.user?.companyCode) {
      res.status(403).json({
        success: false,
        message: "다른 회사의 오버라이드 키를 생성할 권한이 없습니다.",
        error: {
          code: "PERMISSION_DENIED",
          details: "Cannot create override keys for other companies",
        },
      });
      return;
    }
    const multiLangService = new MultiLangService();
    const keyId = await multiLangService.createOverrideKey({
      ...overrideData,
      createdBy: req.user?.userId || "system",
    });
    const response: ApiResponse<number> = {
      success: true,
      message: "오버라이드 키가 성공적으로 생성되었습니다.",
      data: keyId,
    };
    res.status(201).json(response);
  } catch (error) {
    logger.error("오버라이드 키 생성 실패:", error);
    res.status(500).json({
      success: false,
      message: "오버라이드 키 생성 중 오류가 발생했습니다.",
      error: {
        code: "OVERRIDE_KEY_CREATE_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    });
  }
 };
 /**
 * GET /api/multilang/keys/overrides/:companyCode
 * 회사별 오버라이드 키 목록 조회 API
 */
 export const getOverrideKeys = async (
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> => {
  try {
    const { companyCode } = req.params;
    logger.info("오버라이드 키 목록 조회 요청", { companyCode, user: req.user });
    // 권한 검사: 최고 관리자 또는 해당 회사 관리자만 조회 가능
    if (req.user?.companyCode !== "*" && companyCode !== req.user?.companyCode) {
      res.status(403).json({
        success: false,
        message: "다른 회사의 오버라이드 키를 조회할 권한이 없습니다.",
        error: {
          code: "PERMISSION_DENIED",
          details: "Cannot view override keys for other companies",
        },
      });
      return;
    }
    const multiLangService = new MultiLangService();
    const keys = await multiLangService.getOverrideKeys(companyCode);
    const response: ApiResponse<any[]> = {
      success: true,
      message: "오버라이드 키 목록 조회 성공",
      data: keys,
    };
    res.status(200).json(response);
  } catch (error) {
    logger.error("오버라이드 키 목록 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "오버라이드 키 목록 조회 중 오류가 발생했습니다.",
      error: {
        code: "OVERRIDE_KEYS_LIST_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    });
  }
 };
 /**
 * POST /api/multilang/batch
 * 다국어 텍스트 배치 조회 API
@ -1099,86 +710,3 @@ export const getBatchTranslations = async (
    });
  }
 };
 /**
 * POST /api/multilang/screen-labels
 * 화면 라벨 다국어 키 자동 생성 API
 */
 export const generateScreenLabelKeys = async (
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> => {
  try {
    const { screenId, menuObjId, labels } = req.body;
    logger.info("화면 라벨 다국어 키 생성 요청", {
      screenId,
      menuObjId,
      labelCount: labels?.length,
      user: req.user,
    });
    // 필수 파라미터 검증
    if (!screenId) {
      res.status(400).json({
        success: false,
        message: "screenId는 필수입니다.",
        error: { code: "MISSING_SCREEN_ID" },
      });
      return;
    }
    if (!labels || !Array.isArray(labels) || labels.length === 0) {
      res.status(400).json({
        success: false,
        message: "labels 배열이 필요합니다.",
        error: { code: "MISSING_LABELS" },
      });
      return;
    }
    // 화면의 회사 정보 조회 (사용자 회사가 아닌 화면 소속 회사 기준)
    const { queryOne } = await import("../database/db");
    const screenInfo = await queryOne<{ company_code: string }>(
      `SELECT company_code FROM screen_definitions WHERE screen_id = $1`,
      [screenId]
    );
    const companyCode = screenInfo?.company_code || req.user?.companyCode || "*";
    // 회사명 조회
    const companyInfo = await queryOne<{ company_name: string }>(
      `SELECT company_name FROM company_mng WHERE company_code = $1`,
      [companyCode]
    );
    const companyName = companyCode === "*" ? "공통" : (companyInfo?.company_name || companyCode);
    logger.info("화면 소속 회사 정보", { screenId, companyCode, companyName });
    const multiLangService = new MultiLangService();
    const results = await multiLangService.generateScreenLabelKeys({
      screenId: Number(screenId),
      companyCode,
      companyName,
      menuObjId,
      labels,
    });
    const response: ApiResponse<typeof results> = {
      success: true,
      message: `${results.length}개의 다국어 키가 생성되었습니다.`,
      data: results,
    };
    res.status(200).json(response);
  } catch (error) {
    logger.error("화면 라벨 다국어 키 생성 실패:", error);
    res.status(500).json({
      success: false,
      message: "화면 라벨 다국어 키 생성 중 오류가 발생했습니다.",
      error: {
        code: "SCREEN_LABEL_KEY_GENERATION_ERROR",
        details: error instanceof Error ? error.message : "Unknown error",
      },
    });
  }
 };
--- a/backend-node/src/controllers/numberingRuleController.ts
+++ b/backend-node/src/controllers/numberingRuleController.ts
@ -217,14 +217,11 @@ router.post("/:ruleId/allocate", authenticateToken, async (req: AuthenticatedReq
  const companyCode = req.user!.companyCode;
  const { ruleId } = req.params;
  logger.info("코드 할당 요청", { ruleId, companyCode });
  try {
    const allocatedCode = await numberingRuleService.allocateCode(ruleId, companyCode);
    logger.info("코드 할당 성공", { ruleId, allocatedCode });
    return res.json({ success: true, data: { generatedCode: allocatedCode } });
  } catch (error: any) {
-    logger.error("코드 할당 실패", { ruleId, companyCode, error: error.message });
+    logger.error("코드 할당 실패", { error: error.message });
    return res.status(500).json({ success: false, error: error.message });
  }
 });
--- a/backend-node/src/controllers/screenGroupController.ts
+++ b/backend-node/src/controllers/screenGroupController.ts
--- a/backend-node/src/controllers/tableManagementController.ts
+++ b/backend-node/src/controllers/tableManagementController.ts
@ -775,25 +775,13 @@ export async function getTableData(
      const userField = autoFilter?.userField || "companyCode";
      const userValue = (req.user as any)[userField];
-      // 🆕 프리뷰용 회사 코드 오버라이드 (최고 관리자만 허용)
+      if (userValue) {
-      let finalCompanyCode = userValue;
+        enhancedSearch[filterColumn] = userValue;
      if (autoFilter?.companyCodeOverride && userValue === "*") {
        // 최고 관리자만 다른 회사 코드로 오버라이드 가능
        finalCompanyCode = autoFilter.companyCodeOverride;
        logger.info("🔓 최고 관리자 회사 코드 오버라이드:", {
          originalCompanyCode: userValue,
          overrideCompanyCode: autoFilter.companyCodeOverride,
          tableName,
        });
      }
      if (finalCompanyCode) {
        enhancedSearch[filterColumn] = finalCompanyCode;
        logger.info("🔍 현재 사용자 필터 적용:", {
          filterColumn,
          userField,
-          userValue: finalCompanyCode,
+          userValue,
          tableName,
        });
      } else {
@ -2179,104 +2167,3 @@ export async function multiTableSave(
  }
 }
 /**
 * 두 테이블 간 엔티티 관계 조회
 * column_labels의 entity/category 타입 설정을 기반으로 두 테이블 간의 관계를 조회
 */
 export async function getTableEntityRelations(
  req: AuthenticatedRequest,
  res: Response
 ): Promise<void> {
  try {
    const { leftTable, rightTable } = req.query;
    if (!leftTable || !rightTable) {
      res.status(400).json({
        success: false,
        message: "leftTable과 rightTable 파라미터가 필요합니다.",
      });
      return;
    }
    logger.info("=== 테이블 엔티티 관계 조회 ===", { leftTable, rightTable });
    // 두 테이블의 컬럼 라벨 정보 조회
    const columnLabelsQuery = `
      SELECT 
        table_name,
        column_name,
        column_label,
        web_type,
        detail_settings
      FROM column_labels
      WHERE table_name IN ($1, $2)
        AND web_type IN ('entity', 'category')
    `;
    const result = await query(columnLabelsQuery, [leftTable, rightTable]);
    // 관계 분석
    const relations: Array<{
      fromTable: string;
      fromColumn: string;
      toTable: string;
      toColumn: string;
      relationType: string;
    }> = [];
    for (const row of result) {
      try {
        const detailSettings = typeof row.detail_settings === "string" 
          ? JSON.parse(row.detail_settings) 
          : row.detail_settings;
        if (detailSettings && detailSettings.referenceTable) {
          const refTable = detailSettings.referenceTable;
          const refColumn = detailSettings.referenceColumn || "id";
          // leftTable과 rightTable 간의 관계인지 확인
          if (
            (row.table_name === leftTable && refTable === rightTable) ||
            (row.table_name === rightTable && refTable === leftTable)
          ) {
            relations.push({
              fromTable: row.table_name,
              fromColumn: row.column_name,
              toTable: refTable,
              toColumn: refColumn,
              relationType: row.web_type,
            });
          }
        }
      } catch (parseError) {
        logger.warn("detail_settings 파싱 오류:", { 
          table: row.table_name, 
          column: row.column_name,
          error: parseError 
        });
      }
    }
    logger.info("테이블 엔티티 관계 조회 완료", { 
      leftTable, 
      rightTable, 
      relationsCount: relations.length 
    });
    res.json({
      success: true,
      data: {
        leftTable,
        rightTable,
        relations,
      },
    });
  } catch (error: any) {
    logger.error("테이블 엔티티 관계 조회 실패:", error);
    res.status(500).json({
      success: false,
      message: "테이블 엔티티 관계 조회에 실패했습니다.",
      error: error.message,
    });
  }
 }
--- a/backend-node/src/routes/authRoutes.ts
+++ b/backend-node/src/routes/authRoutes.ts
@ -47,10 +47,4 @@ router.post("/refresh", AuthController.refreshToken);
 */
 router.post("/signup", AuthController.signup);
 /**
 * POST /api/auth/switch-company
 * WACE 관리자 전용: 다른 회사로 전환
 */
 router.post("/switch-company", AuthController.switchCompany);
 export default router;
--- a/backend-node/src/routes/cascadingAutoFillRoutes.ts
+++ b/backend-node/src/routes/cascadingAutoFillRoutes.ts
@ -55,5 +55,3 @@ export default router;
--- a/backend-node/src/routes/cascadingConditionRoutes.ts
+++ b/backend-node/src/routes/cascadingConditionRoutes.ts
@ -51,5 +51,3 @@ export default router;
--- a/backend-node/src/routes/cascadingHierarchyRoutes.ts
+++ b/backend-node/src/routes/cascadingHierarchyRoutes.ts
@ -67,5 +67,3 @@ export default router;
--- a/backend-node/src/routes/cascadingMutualExclusionRoutes.ts
+++ b/backend-node/src/routes/cascadingMutualExclusionRoutes.ts
@ -55,5 +55,3 @@ export default router;
--- a/backend-node/src/routes/codeMergeRoutes.ts
+++ b/backend-node/src/routes/codeMergeRoutes.ts
@ -3,8 +3,6 @@ import {
  mergeCodeAllTables,
  getTablesWithColumn,
  previewCodeMerge,
  mergeCodeByValue,
  previewMergeCodeByValue,
 } from "../controllers/codeMergeController";
 import { authenticateToken } from "../middleware/authMiddleware";
@ -15,7 +13,7 @@ router.use(authenticateToken);
 /**
 * POST /api/code-merge/merge-all-tables
- * 코드 병합 실행 (모든 관련 테이블에 적용 - 같은 컬럼명만)
+ * 코드 병합 실행 (모든 관련 테이블에 적용)
 * Body: { columnName, oldValue, newValue }
 */
 router.post("/merge-all-tables", mergeCodeAllTables);
@ -28,24 +26,10 @@ router.get("/tables-with-column/:columnName", getTablesWithColumn);
 /**
 * POST /api/code-merge/preview
- * 코드 병합 미리보기 (같은 컬럼명 기준)
+ * 코드 병합 미리보기 (실제 실행 없이 영향받을 데이터 확인)
 * Body: { columnName, oldValue }
 */
 router.post("/preview", previewCodeMerge);
 /**
 * POST /api/code-merge/merge-by-value
 * 값 기반 코드 병합 (모든 테이블의 모든 컬럼에서 해당 값을 찾아 변경)
 * Body: { oldValue, newValue }
 */
 router.post("/merge-by-value", mergeCodeByValue);
 /**
 * POST /api/code-merge/preview-by-value
 * 값 기반 코드 병합 미리보기 (컬럼명 상관없이 값으로 검색)
 * Body: { oldValue }
 */
 router.post("/preview-by-value", previewMergeCodeByValue);
 export default router;
--- a/backend-node/src/routes/dataRoutes.ts
+++ b/backend-node/src/routes/dataRoutes.ts
@ -1,262 +1,10 @@
 import express from "express";
 import { dataService } from "../services/dataService";
 import { masterDetailExcelService } from "../services/masterDetailExcelService";
 import { authenticateToken } from "../middleware/authMiddleware";
 import { AuthenticatedRequest } from "../types/auth";
 const router = express.Router();
 // ================================
 // 마스터-디테일 엑셀 API
 // ================================
 /**
 * 마스터-디테일 관계 정보 조회
 * GET /api/data/master-detail/relation/:screenId
 */
 router.get(
  "/master-detail/relation/:screenId",
  authenticateToken,
  async (req: AuthenticatedRequest, res) => {
    try {
      const { screenId } = req.params;
      if (!screenId || isNaN(parseInt(screenId))) {
        return res.status(400).json({
          success: false,
          message: "유효한 screenId가 필요합니다.",
        });
      }
      console.log(`🔍 마스터-디테일 관계 조회: screenId=${screenId}`);
      const relation = await masterDetailExcelService.getMasterDetailRelation(
        parseInt(screenId)
      );
      if (!relation) {
        return res.json({
          success: true,
          data: null,
          message: "마스터-디테일 구조가 아닙니다.",
        });
      }
      console.log(`✅ 마스터-디테일 관계 발견:`, {
        masterTable: relation.masterTable,
        detailTable: relation.detailTable,
        joinKey: relation.masterKeyColumn,
      });
      return res.json({
        success: true,
        data: relation,
      });
    } catch (error: any) {
      console.error("마스터-디테일 관계 조회 오류:", error);
      return res.status(500).json({
        success: false,
        message: "마스터-디테일 관계 조회 중 오류가 발생했습니다.",
        error: error.message,
      });
    }
  }
 );
 /**
 * 마스터-디테일 엑셀 다운로드 데이터 조회
 * POST /api/data/master-detail/download
 */
 router.post(
  "/master-detail/download",
  authenticateToken,
  async (req: AuthenticatedRequest, res) => {
    try {
      const { screenId, filters } = req.body;
      const companyCode = req.user?.companyCode || "*";
      if (!screenId) {
        return res.status(400).json({
          success: false,
          message: "screenId가 필요합니다.",
        });
      }
      console.log(`📥 마스터-디테일 엑셀 다운로드: screenId=${screenId}`);
      // 1. 마스터-디테일 관계 조회
      const relation = await masterDetailExcelService.getMasterDetailRelation(
        parseInt(screenId)
      );
      if (!relation) {
        return res.status(400).json({
          success: false,
          message: "마스터-디테일 구조가 아닙니다.",
        });
      }
      // 2. JOIN 데이터 조회
      const data = await masterDetailExcelService.getJoinedData(
        relation,
        companyCode,
        filters
      );
      console.log(`✅ 마스터-디테일 데이터 조회 완료: ${data.data.length}행`);
      return res.json({
        success: true,
        data,
      });
    } catch (error: any) {
      console.error("마스터-디테일 다운로드 오류:", error);
      return res.status(500).json({
        success: false,
        message: "마스터-디테일 다운로드 중 오류가 발생했습니다.",
        error: error.message,
      });
    }
  }
 );
 /**
 * 마스터-디테일 엑셀 업로드
 * POST /api/data/master-detail/upload
 */
 router.post(
  "/master-detail/upload",
  authenticateToken,
  async (req: AuthenticatedRequest, res) => {
    try {
      const { screenId, data } = req.body;
      const companyCode = req.user?.companyCode || "*";
      const userId = req.user?.userId;
      if (!screenId || !data || !Array.isArray(data)) {
        return res.status(400).json({
          success: false,
          message: "screenId와 data 배열이 필요합니다.",
        });
      }
      console.log(`📤 마스터-디테일 엑셀 업로드: screenId=${screenId}, rows=${data.length}`);
      // 1. 마스터-디테일 관계 조회
      const relation = await masterDetailExcelService.getMasterDetailRelation(
        parseInt(screenId)
      );
      if (!relation) {
        return res.status(400).json({
          success: false,
          message: "마스터-디테일 구조가 아닙니다.",
        });
      }
      // 2. 데이터 업로드
      const result = await masterDetailExcelService.uploadJoinedData(
        relation,
        data,
        companyCode,
        userId
      );
      console.log(`✅ 마스터-디테일 업로드 완료:`, {
        masterInserted: result.masterInserted,
        masterUpdated: result.masterUpdated,
        detailInserted: result.detailInserted,
        errors: result.errors.length,
      });
      return res.json({
        success: result.success,
        data: result,
        message: result.success
          ? `마스터 ${result.masterInserted + result.masterUpdated}건, 디테일 ${result.detailInserted}건 처리되었습니다.`
          : "업로드 중 오류가 발생했습니다.",
      });
    } catch (error: any) {
      console.error("마스터-디테일 업로드 오류:", error);
      return res.status(500).json({
        success: false,
        message: "마스터-디테일 업로드 중 오류가 발생했습니다.",
        error: error.message,
      });
    }
  }
 );
 /**
 * 마스터-디테일 간단 모드 엑셀 업로드
 * - 마스터 정보는 UI에서 선택
 * - 디테일 정보만 엑셀에서 업로드
 * - 채번 규칙을 통해 마스터 키 자동 생성
 * 
 * POST /api/data/master-detail/upload-simple
 */
 router.post(
  "/master-detail/upload-simple",
  authenticateToken,
  async (req: AuthenticatedRequest, res) => {
    try {
      const { screenId, detailData, masterFieldValues, numberingRuleId, afterUploadFlowId, afterUploadFlows } = req.body;
      const companyCode = req.user?.companyCode || "*";
      const userId = req.user?.userId || "system";
      if (!screenId || !detailData || !Array.isArray(detailData)) {
        return res.status(400).json({
          success: false,
          message: "screenId와 detailData 배열이 필요합니다.",
        });
      }
      console.log(`📤 마스터-디테일 간단 모드 업로드: screenId=${screenId}, rows=${detailData.length}`);
      console.log(`   마스터 필드 값:`, masterFieldValues);
      console.log(`   채번 규칙 ID:`, numberingRuleId);
      console.log(`   업로드 후 제어:`, afterUploadFlows?.length > 0 ? `${afterUploadFlows.length}개` : afterUploadFlowId || "없음");
      // 업로드 실행
      const result = await masterDetailExcelService.uploadSimple(
        parseInt(screenId),
        detailData,
        masterFieldValues || {},
        numberingRuleId,
        companyCode,
        userId,
        afterUploadFlowId, // 업로드 후 제어 실행 (단일, 하위 호환성)
        afterUploadFlows // 업로드 후 제어 실행 (다중)
      );
      console.log(`✅ 마스터-디테일 간단 모드 업로드 완료:`, {
        masterInserted: result.masterInserted,
        detailInserted: result.detailInserted,
        generatedKey: result.generatedKey,
        errors: result.errors.length,
      });
      return res.json({
        success: result.success,
        data: result,
        message: result.success
          ? `마스터 1건(${result.generatedKey}), 디테일 ${result.detailInserted}건 처리되었습니다.`
          : "업로드 중 오류가 발생했습니다.",
      });
    } catch (error: any) {
      console.error("마스터-디테일 간단 모드 업로드 오류:", error);
      return res.status(500).json({
        success: false,
        message: "마스터-디테일 업로드 중 오류가 발생했습니다.",
        error: error.message,
      });
    }
  }
 );
 // ================================
 // 기존 데이터 API
 // ================================
 /**
 * 조인 데이터 조회 API (다른 라우트보다 먼저 정의)
 * GET /api/data/join?leftTable=...&rightTable=...&leftColumn=...&rightColumn=...&leftValue=...
@ -950,7 +698,6 @@ router.post(
    try {
      const { tableName } = req.params;
      const filterConditions = req.body;
      const userCompany = req.user?.companyCode;
      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName)) {
        return res.status(400).json({
@ -959,12 +706,11 @@ router.post(
        });
      }
-      console.log(`🗑️ 그룹 삭제:`, { tableName, filterConditions, userCompany });
+      console.log(`🗑️ 그룹 삭제:`, { tableName, filterConditions });
      const result = await dataService.deleteGroupRecords(
        tableName,
-        filterConditions,
+        filterConditions
        userCompany // 회사 코드 전달
      );
      if (!result.success) {
--- a/backend-node/src/routes/dataflow/node-flows.ts
+++ b/backend-node/src/routes/dataflow/node-flows.ts
@ -214,73 +214,6 @@ router.delete("/:flowId", async (req: Request, res: Response) => {
  }
 });
 /**
 * 플로우 소스 테이블 조회
 * GET /api/dataflow/node-flows/:flowId/source-table
 * 플로우의 첫 번째 소스 노드(tableSource, externalDBSource)에서 테이블명 추출
 */
 router.get("/:flowId/source-table", async (req: Request, res: Response) => {
  try {
    const { flowId } = req.params;
    const flow = await queryOne<{ flow_data: any }>(
      `SELECT flow_data FROM node_flows WHERE flow_id = $1`,
      [flowId]
    );
    if (!flow) {
      return res.status(404).json({
        success: false,
        message: "플로우를 찾을 수 없습니다.",
      });
    }
    const flowData =
      typeof flow.flow_data === "string"
        ? JSON.parse(flow.flow_data)
        : flow.flow_data;
    const nodes = flowData.nodes || [];
    // 소스 노드 찾기 (tableSource, externalDBSource 타입)
    const sourceNode = nodes.find(
      (node: any) =>
        node.type === "tableSource" || node.type === "externalDBSource"
    );
    if (!sourceNode || !sourceNode.data?.tableName) {
      return res.json({
        success: true,
        data: {
          sourceTable: null,
          sourceNodeType: null,
          message: "소스 노드가 없거나 테이블명이 설정되지 않았습니다.",
        },
      });
    }
    logger.info(
      `플로우 소스 테이블 조회: flowId=${flowId}, table=${sourceNode.data.tableName}`
    );
    return res.json({
      success: true,
      data: {
        sourceTable: sourceNode.data.tableName,
        sourceNodeType: sourceNode.type,
        sourceNodeId: sourceNode.id,
        displayName: sourceNode.data.displayName,
      },
    });
  } catch (error) {
    logger.error("플로우 소스 테이블 조회 실패:", error);
    return res.status(500).json({
      success: false,
      message: "플로우 소스 테이블을 조회하지 못했습니다.",
    });
  }
 });
 /**
 * 플로우 실행
 * POST /api/dataflow/node-flows/:flowId/execute
--- a/backend-node/src/routes/excelMappingRoutes.ts
+++ b/backend-node/src/routes/excelMappingRoutes.ts
@ -1,25 +0,0 @@
 import { Router } from "express";
 import { authenticateToken } from "../middleware/authMiddleware";
 import {
  findMappingByColumns,
  saveMappingTemplate,
  getMappingTemplates,
  deleteMappingTemplate,
 } from "../controllers/excelMappingController";
 const router = Router();
 // 엑셀 컬럼 구조로 매핑 템플릿 조회
 router.post("/find", authenticateToken, findMappingByColumns);
 // 매핑 템플릿 저장 (UPSERT)
 router.post("/save", authenticateToken, saveMappingTemplate);
 // 테이블의 매핑 템플릿 목록 조회
 router.get("/list/:tableName", authenticateToken, getMappingTemplates);
 // 매핑 템플릿 삭제
 router.delete("/:id", authenticateToken, deleteMappingTemplate);
 export default router;
--- a/backend-node/src/routes/multilangRoutes.ts
+++ b/backend-node/src/routes/multilangRoutes.ts
@ -21,20 +21,6 @@ import {
  getUserText,
  getLangText,
  getBatchTranslations,
  // 카테고리 관리 API
  getCategories,
  getCategoryById,
  getCategoryPath,
  // 자동 생성 및 오버라이드 API
  generateKey,
  previewKey,
  createOverrideKey,
  getOverrideKeys,
  // 화면 라벨 다국어 API
  generateScreenLabelKeys,
 } from "../controllers/multilangController";
 const router = express.Router();
@ -65,18 +51,4 @@ router.post("/keys/:keyId/texts", saveLangTexts); // 다국어 텍스트 저장/
 router.get("/user-text/:companyCode/:menuCode/:langKey", getUserText); // 사용자별 다국어 텍스트 조회
 router.get("/text/:companyCode/:langKey/:langCode", getLangText); // 특정 키의 다국어 텍스트 조회
 // 카테고리 관리 API
 router.get("/categories", getCategories); // 카테고리 트리 조회
 router.get("/categories/:categoryId", getCategoryById); // 카테고리 상세 조회
 router.get("/categories/:categoryId/path", getCategoryPath); // 카테고리 경로 조회
 // 자동 생성 및 오버라이드 API
 router.post("/keys/generate", generateKey); // 키 자동 생성
 router.post("/keys/preview", previewKey); // 키 미리보기
 router.post("/keys/override", createOverrideKey); // 오버라이드 키 생성
 router.get("/keys/overrides/:companyCode", getOverrideKeys); // 오버라이드 키 목록 조회
 // 화면 라벨 다국어 자동 생성 API
 router.post("/screen-labels", generateScreenLabelKeys); // 화면 라벨 다국어 키 자동 생성
 export default router;
--- a/backend-node/src/routes/screenGroupRoutes.ts
+++ b/backend-node/src/routes/screenGroupRoutes.ts
@ -1,111 +0,0 @@
 import { Router } from "express";
 import { authenticateToken } from "../middleware/authMiddleware";
 import {
  // 화면 그룹
  getScreenGroups,
  getScreenGroup,
  createScreenGroup,
  updateScreenGroup,
  deleteScreenGroup,
  // 화면-그룹 연결
  addScreenToGroup,
  removeScreenFromGroup,
  updateScreenInGroup,
  // 필드 조인
  getFieldJoins,
  createFieldJoin,
  updateFieldJoin,
  deleteFieldJoin,
  // 데이터 흐름
  getDataFlows,
  createDataFlow,
  updateDataFlow,
  deleteDataFlow,
  // 화면-테이블 관계
  getTableRelations,
  createTableRelation,
  updateTableRelation,
  deleteTableRelation,
  // 화면 레이아웃 요약
  getScreenLayoutSummary,
  getMultipleScreenLayoutSummary,
  // 화면 서브 테이블 관계
  getScreenSubTables,
  // 메뉴-화면그룹 동기화
  syncScreenGroupsToMenuController,
  syncMenuToScreenGroupsController,
  getSyncStatusController,
  syncAllCompaniesController,
 } from "../controllers/screenGroupController";
 const router = Router();
 // 모든 라우트에 인증 미들웨어 적용
 router.use(authenticateToken);
 // ============================================================
 // 화면 그룹 (screen_groups)
 // ============================================================
 router.get("/groups", getScreenGroups);
 router.get("/groups/:id", getScreenGroup);
 router.post("/groups", createScreenGroup);
 router.put("/groups/:id", updateScreenGroup);
 router.delete("/groups/:id", deleteScreenGroup);
 // ============================================================
 // 화면-그룹 연결 (screen_group_screens)
 // ============================================================
 router.post("/group-screens", addScreenToGroup);
 router.put("/group-screens/:id", updateScreenInGroup);
 router.delete("/group-screens/:id", removeScreenFromGroup);
 // ============================================================
 // 필드 조인 설정 (screen_field_joins)
 // ============================================================
 router.get("/field-joins", getFieldJoins);
 router.post("/field-joins", createFieldJoin);
 router.put("/field-joins/:id", updateFieldJoin);
 router.delete("/field-joins/:id", deleteFieldJoin);
 // ============================================================
 // 데이터 흐름 (screen_data_flows)
 // ============================================================
 router.get("/data-flows", getDataFlows);
 router.post("/data-flows", createDataFlow);
 router.put("/data-flows/:id", updateDataFlow);
 router.delete("/data-flows/:id", deleteDataFlow);
 // ============================================================
 // 화면-테이블 관계 (screen_table_relations)
 // ============================================================
 router.get("/table-relations", getTableRelations);
 router.post("/table-relations", createTableRelation);
 router.put("/table-relations/:id", updateTableRelation);
 router.delete("/table-relations/:id", deleteTableRelation);
 // ============================================================
 // 화면 레이아웃 요약 (미리보기용)
 // ============================================================
 router.get("/layout-summary/:screenId", getScreenLayoutSummary);
 router.post("/layout-summary/batch", getMultipleScreenLayoutSummary);
 // ============================================================
 // 화면 서브 테이블 관계 (조인/참조 테이블)
 // ============================================================
 router.post("/sub-tables/batch", getScreenSubTables);
 // ============================================================
 // 메뉴-화면그룹 동기화
 // ============================================================
 // 동기화 상태 조회
 router.get("/sync/status", getSyncStatusController);
 // 화면관리 → 메뉴 동기화
 router.post("/sync/screen-to-menu", syncScreenGroupsToMenuController);
 // 메뉴 → 화면관리 동기화
 router.post("/sync/menu-to-screen", syncMenuToScreenGroupsController);
 // 전체 회사 동기화 (최고 관리자만)
 router.post("/sync/all", syncAllCompaniesController);
 export default router;
--- a/backend-node/src/routes/tableManagementRoutes.ts
+++ b/backend-node/src/routes/tableManagementRoutes.ts
@ -25,7 +25,6 @@ import {
  toggleLogTable,
  getCategoryColumnsByMenu, // 🆕 메뉴별 카테고리 컬럼 조회
  multiTableSave, // 🆕 범용 다중 테이블 저장
  getTableEntityRelations, // 🆕 두 테이블 간 엔티티 관계 조회
 } from "../controllers/tableManagementController";
 const router = express.Router();
@ -39,15 +38,6 @@ router.use(authenticateToken);
 */
 router.get("/tables", getTableList);
 /**
 * 두 테이블 간 엔티티 관계 조회
 * GET /api/table-management/tables/entity-relations?leftTable=xxx&rightTable=yyy
 * 
 * column_labels에서 정의된 엔티티/카테고리 타입 설정을 기반으로
 * 두 테이블 간의 외래키 관계를 자동으로 감지합니다.
 */
 router.get("/tables/entity-relations", getTableEntityRelations);
 /**
 * 테이블 컬럼 정보 조회
 * GET /api/table-management/tables/:tableName/columns
--- a/backend-node/src/services/adminService.ts
+++ b/backend-node/src/services/adminService.ts
@ -65,13 +65,6 @@ export class AdminService {
          }
        );
        // [임시 비활성화] 메뉴 권한 그룹 체크 - 모든 사용자에게 전체 메뉴 표시
        // TODO: 권한 체크 다시 활성화 필요
        logger.info(
          `⚠️ [임시 비활성화] 권한 그룹 체크 스킵 - 사용자 ${userId}(${userType})에게 전체 메뉴 표시`
        );
        /* [원본 코드 - 권한 그룹 체크]
        if (userType === "COMPANY_ADMIN") {
          // 회사 관리자: 권한 그룹 기반 필터링 적용
          if (userRoleGroups.length > 0) {
@ -148,7 +141,6 @@ export class AdminService {
            return [];
          }
        }
        */
      } else if (
        menuType !== undefined &&
        userType === "SUPER_ADMIN" &&
@ -420,18 +412,9 @@ export class AdminService {
      let queryParams: any[] = [userLang];
      let paramIndex = 2;
-      // [임시 비활성화] 메뉴 권한 그룹 체크 - 모든 사용자에게 전체 메뉴 표시
+      if (userType === "SUPER_ADMIN" && userCompanyCode === "*") {
-      // TODO: 권한 체크 다시 활성화 필요
+        // SUPER_ADMIN: 권한 그룹 체크 없이 공통 메뉴만 표시
-      logger.info(
+        logger.info("✅ 좌측 사이드바 (SUPER_ADMIN): 공통 메뉴만 표시");
        `⚠️ [임시 비활성화] getUserMenuList 권한 그룹 체크 스킵 - 사용자 ${userId}(${userType})에게 전체 메뉴 표시`
      );
      authFilter = "";
      unionFilter = "";
      /* [원본 코드 - getUserMenuList 권한 그룹 체크]
      if (userType === "SUPER_ADMIN") {
        // SUPER_ADMIN: 권한 그룹 체크 없이 해당 회사의 모든 메뉴 표시
        logger.info(`✅ 좌측 사이드바 (SUPER_ADMIN): 회사 ${userCompanyCode}의 모든 메뉴 표시`);
        authFilter = "";
        unionFilter = "";
      } else {
@ -488,7 +471,6 @@ export class AdminService {
          return [];
        }
      }
      */
      // 2. 회사별 필터링 조건 생성
      let companyFilter = "";
--- a/backend-node/src/services/dataService.ts
+++ b/backend-node/src/services/dataService.ts
@ -254,10 +254,7 @@ class DataService {
          key !== "limit" &&
          key !== "offset" &&
          key !== "orderBy" &&
-          key !== "userLang" &&
+          key !== "userLang"
          key !== "page" &&
          key !== "pageSize" &&
          key !== "size"
        ) {
          // 컬럼명 검증 (SQL 인젝션 방지)
          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
@ -1192,13 +1189,6 @@ class DataService {
        [tableName]
      );
      console.log(`🔍 테이블 ${tableName}의 Primary Key 조회 결과:`, {
        pkColumns: pkResult.map((r) => r.attname),
        pkCount: pkResult.length,
        inputId: typeof id === "object" ? JSON.stringify(id).substring(0, 200) + "..." : id,
        inputIdType: typeof id,
      });
      let whereClauses: string[] = [];
      let params: any[] = [];
@ -1226,31 +1216,17 @@ class DataService {
        params.push(typeof id === "object" ? id[pkColumn] : id);
      }
-      const queryText = `DELETE FROM "${tableName}" WHERE ${whereClauses.join(" AND ")} RETURNING *`;
+      const queryText = `DELETE FROM "${tableName}" WHERE ${whereClauses.join(" AND ")}`;
      console.log(`🗑️ 삭제 쿼리:`, queryText, params);
      const result = await query<any>(queryText, params);
      // 삭제된 행이 없으면 실패 처리
      if (result.length === 0) {
        console.warn(
          `⚠️ 레코드 삭제 실패: ${tableName}, 해당 조건에 맞는 레코드가 없습니다.`,
          { whereClauses, params }
        );
        return {
          success: false,
          message: "삭제할 레코드를 찾을 수 없습니다. 이미 삭제되었거나 권한이 없습니다.",
          error: "RECORD_NOT_FOUND",
        };
      }
      console.log(
        `✅ 레코드 삭제 완료: ${tableName}, 영향받은 행: ${result.length}`
      );
      return {
        success: true,
        data: result[0], // 삭제된 레코드 정보 반환
      };
    } catch (error) {
      console.error(`레코드 삭제 오류 (${tableName}):`, error);
@ -1264,14 +1240,10 @@ class DataService {
  /**
   * 조건에 맞는 모든 레코드 삭제 (그룹 삭제)
   * @param tableName 테이블명
   * @param filterConditions 삭제 조건
   * @param userCompany 사용자 회사 코드 (멀티테넌시 필터링)
   */
  async deleteGroupRecords(
    tableName: string,
-    filterConditions: Record<string, any>,
+    filterConditions: Record<string, any>
    userCompany?: string
  ): Promise<ServiceResponse<{ deleted: number }>> {
    try {
      const validation = await this.validateTableAccess(tableName);
@ -1283,7 +1255,6 @@ class DataService {
      const whereValues: any[] = [];
      let paramIndex = 1;
      // 사용자 필터 조건 추가
      for (const [key, value] of Object.entries(filterConditions)) {
        whereConditions.push(`"${key}" = $${paramIndex}`);
        whereValues.push(value);
@ -1298,24 +1269,10 @@ class DataService {
        };
      }
      // 🔒 멀티테넌시: company_code 필터링 (최고 관리자 제외)
      const hasCompanyCode = await this.checkColumnExists(tableName, "company_code");
      if (hasCompanyCode && userCompany && userCompany !== "*") {
        whereConditions.push(`"company_code" = $${paramIndex}`);
        whereValues.push(userCompany);
        paramIndex++;
        console.log(`🔒 멀티테넌시 필터 적용: company_code = ${userCompany}`);
      }
      const whereClause = whereConditions.join(" AND ");
      const deleteQuery = `DELETE FROM "${tableName}" WHERE ${whereClause} RETURNING *`;
-      console.log(`🗑️ 그룹 삭제:`, { 
+      console.log(`🗑️ 그룹 삭제:`, { tableName, conditions: filterConditions });
        tableName, 
        conditions: filterConditions,
        userCompany,
        whereClause,
      });
      const result = await pool.query(deleteQuery, whereValues);
--- a/backend-node/src/services/dynamicFormService.ts
+++ b/backend-node/src/services/dynamicFormService.ts
@ -1,7 +1,6 @@
 import { query, queryOne, transaction, getPool } from "../database/db";
 import { EventTriggerService } from "./eventTriggerService";
 import { DataflowControlService } from "./dataflowControlService";
 import tableCategoryValueService from "./tableCategoryValueService";
 export interface FormDataResult {
  id: number;
@ -428,24 +427,6 @@ export class DynamicFormService {
        dataToInsert,
      });
      // 카테고리 타입 컬럼의 라벨 값을 코드 값으로 변환 (엑셀 업로드 등 지원)
      console.log("🏷️ 카테고리 라벨→코드 변환 시작...");
      const companyCodeForCategory = company_code || "*";
      const { convertedData: categoryConvertedData, conversions } = 
        await tableCategoryValueService.convertCategoryLabelsToCodesForData(
          tableName,
          companyCodeForCategory,
          dataToInsert
        );
      if (conversions.length > 0) {
        console.log(`🏷️ 카테고리 라벨→코드 변환 완료: ${conversions.length}개`, conversions);
        // 변환된 데이터로 교체
        Object.assign(dataToInsert, categoryConvertedData);
      } else {
        console.log("🏷️ 카테고리 라벨→코드 변환 없음 (카테고리 컬럼 없거나 이미 코드 값)");
      }
      // 테이블 컬럼 정보 조회하여 타입 변환 적용
      console.log("🔍 테이블 컬럼 정보 조회 중...");
      const columnInfo = await this.getTableColumnInfo(tableName);
@ -1192,18 +1173,12 @@ export class DynamicFormService {
  /**
   * 폼 데이터 삭제 (실제 테이블에서 직접 삭제)
   * @param id 삭제할 레코드 ID
   * @param tableName 테이블명
   * @param companyCode 회사 코드
   * @param userId 사용자 ID
   * @param screenId 화면 ID (제어관리 실행용, 선택사항)
   */
  async deleteFormData(
    id: string | number,
    tableName: string,
    companyCode?: string,
-    userId?: string,
+    userId?: string
    screenId?: number
  ): Promise<void> {
    try {
      console.log("🗑️ 서비스: 실제 테이블에서 폼 데이터 삭제 시작:", {
@ -1316,19 +1291,14 @@ export class DynamicFormService {
          const recordCompanyCode =
            deletedRecord?.company_code || companyCode || "*";
          // screenId가 전달되지 않으면 제어관리를 실행하지 않음
          if (screenId && screenId > 0) {
          await this.executeDataflowControlIfConfigured(
-              screenId,
+            0, // DELETE는 screenId를 알 수 없으므로 0으로 설정 (추후 개선 필요)
            tableName,
            deletedRecord,
            "delete",
            userId || "system",
            recordCompanyCode
          );
          } else {
            console.log("ℹ️ screenId가 전달되지 않아 제어관리를 건너뜁니다. (screenId:", screenId, ")");
          }
        }
      } catch (controlError) {
        console.error("⚠️ 제어관리 실행 오류:", controlError);
@ -1673,16 +1643,10 @@ export class DynamicFormService {
            !!properties?.webTypeConfig?.dataflowConfig?.flowControls,
        });
-        // 버튼 컴포넌트이고 제어관리가 활성화된 경우
+        // 버튼 컴포넌트이고 저장 액션이며 제어관리가 활성화된 경우
        // triggerType에 맞는 액션 타입 매칭: insert/update -> save, delete -> delete
        const buttonActionType = properties?.componentConfig?.action?.type;
        const isMatchingAction =
          (triggerType === "delete" && buttonActionType === "delete") ||
          ((triggerType === "insert" || triggerType === "update") && buttonActionType === "save");
        if (
          properties?.componentType === "button-primary" &&
-          isMatchingAction &&
+          properties?.componentConfig?.action?.type === "save" &&
          properties?.webTypeConfig?.enableDataflowControl === true
        ) {
          const dataflowConfig = properties?.webTypeConfig?.dataflowConfig;
--- a/backend-node/src/services/excelMappingService.ts
+++ b/backend-node/src/services/excelMappingService.ts
@ -1,283 +0,0 @@
 import { getPool } from "../database/db";
 import { logger } from "../utils/logger";
 import crypto from "crypto";
 export interface ExcelMappingTemplate {
  id?: number;
  tableName: string;
  excelColumns: string[];
  excelColumnsHash: string;
  columnMappings: Record<string, string | null>; // { "엑셀컬럼": "시스템컬럼" }
  companyCode: string;
  createdDate?: Date;
  updatedDate?: Date;
 }
 class ExcelMappingService {
  /**
   * 엑셀 컬럼 목록으로 해시 생성
   * 정렬 후 MD5 해시 생성하여 동일한 컬럼 구조 식별
   */
  generateColumnsHash(columns: string[]): string {
    // 컬럼 목록을 정렬하여 순서와 무관하게 동일한 해시 생성
    const sortedColumns = [...columns].sort();
    const columnsString = sortedColumns.join("|");
    return crypto.createHash("md5").update(columnsString).digest("hex");
  }
  /**
   * 엑셀 컬럼 구조로 매핑 템플릿 조회
   * 동일한 컬럼 구조가 있으면 기존 매핑 반환
   */
  async findMappingByColumns(
    tableName: string,
    excelColumns: string[],
    companyCode: string
  ): Promise<ExcelMappingTemplate | null> {
    try {
      const hash = this.generateColumnsHash(excelColumns);
      logger.info("엑셀 매핑 템플릿 조회", {
        tableName,
        excelColumns,
        hash,
        companyCode,
      });
      const pool = getPool();
      // 회사별 매핑 먼저 조회, 없으면 공통(*) 매핑 조회
      let query: string;
      let params: any[];
      if (companyCode === "*") {
        query = `
          SELECT 
            id,
            table_name as "tableName",
            excel_columns as "excelColumns",
            excel_columns_hash as "excelColumnsHash",
            column_mappings as "columnMappings",
            company_code as "companyCode",
            created_date as "createdDate",
            updated_date as "updatedDate"
          FROM excel_mapping_template
          WHERE table_name = $1
            AND excel_columns_hash = $2
          ORDER BY updated_date DESC
          LIMIT 1
        `;
        params = [tableName, hash];
      } else {
        query = `
          SELECT 
            id,
            table_name as "tableName",
            excel_columns as "excelColumns",
            excel_columns_hash as "excelColumnsHash",
            column_mappings as "columnMappings",
            company_code as "companyCode",
            created_date as "createdDate",
            updated_date as "updatedDate"
          FROM excel_mapping_template
          WHERE table_name = $1
            AND excel_columns_hash = $2
            AND (company_code = $3 OR company_code = '*')
          ORDER BY 
            CASE WHEN company_code = $3 THEN 0 ELSE 1 END,
            updated_date DESC
          LIMIT 1
        `;
        params = [tableName, hash, companyCode];
      }
      const result = await pool.query(query, params);
      if (result.rows.length > 0) {
        logger.info("기존 매핑 템플릿 발견", {
          id: result.rows[0].id,
          tableName,
        });
        return result.rows[0];
      }
      logger.info("매핑 템플릿 없음 - 새 구조", { tableName, hash });
      return null;
    } catch (error: any) {
      logger.error(`매핑 템플릿 조회 실패: ${error.message}`, { error });
      throw error;
    }
  }
  /**
   * 매핑 템플릿 저장 (UPSERT)
   * 동일한 테이블+컬럼구조+회사코드가 있으면 업데이트, 없으면 삽입
   */
  async saveMappingTemplate(
    tableName: string,
    excelColumns: string[],
    columnMappings: Record<string, string | null>,
    companyCode: string,
    userId?: string
  ): Promise<ExcelMappingTemplate> {
    try {
      const hash = this.generateColumnsHash(excelColumns);
      logger.info("엑셀 매핑 템플릿 저장 (UPSERT)", {
        tableName,
        excelColumns,
        hash,
        columnMappings,
        companyCode,
      });
      const pool = getPool();
      const query = `
        INSERT INTO excel_mapping_template (
          table_name,
          excel_columns,
          excel_columns_hash,
          column_mappings,
          company_code,
          created_date,
          updated_date
        ) VALUES ($1, $2, $3, $4, $5, NOW(), NOW())
        ON CONFLICT (table_name, excel_columns_hash, company_code)
        DO UPDATE SET
          column_mappings = EXCLUDED.column_mappings,
          updated_date = NOW()
        RETURNING 
          id,
          table_name as "tableName",
          excel_columns as "excelColumns",
          excel_columns_hash as "excelColumnsHash",
          column_mappings as "columnMappings",
          company_code as "companyCode",
          created_date as "createdDate",
          updated_date as "updatedDate"
      `;
      const result = await pool.query(query, [
        tableName,
        excelColumns,
        hash,
        JSON.stringify(columnMappings),
        companyCode,
      ]);
      logger.info("매핑 템플릿 저장 완료", {
        id: result.rows[0].id,
        tableName,
        hash,
      });
      return result.rows[0];
    } catch (error: any) {
      logger.error(`매핑 템플릿 저장 실패: ${error.message}`, { error });
      throw error;
    }
  }
  /**
   * 테이블의 모든 매핑 템플릿 조회
   */
  async getMappingTemplates(
    tableName: string,
    companyCode: string
  ): Promise<ExcelMappingTemplate[]> {
    try {
      logger.info("테이블 매핑 템플릿 목록 조회", { tableName, companyCode });
      const pool = getPool();
      let query: string;
      let params: any[];
      if (companyCode === "*") {
        query = `
          SELECT 
            id,
            table_name as "tableName",
            excel_columns as "excelColumns",
            excel_columns_hash as "excelColumnsHash",
            column_mappings as "columnMappings",
            company_code as "companyCode",
            created_date as "createdDate",
            updated_date as "updatedDate"
          FROM excel_mapping_template
          WHERE table_name = $1
          ORDER BY updated_date DESC
        `;
        params = [tableName];
      } else {
        query = `
          SELECT 
            id,
            table_name as "tableName",
            excel_columns as "excelColumns",
            excel_columns_hash as "excelColumnsHash",
            column_mappings as "columnMappings",
            company_code as "companyCode",
            created_date as "createdDate",
            updated_date as "updatedDate"
          FROM excel_mapping_template
          WHERE table_name = $1
            AND (company_code = $2 OR company_code = '*')
          ORDER BY updated_date DESC
        `;
        params = [tableName, companyCode];
      }
      const result = await pool.query(query, params);
      logger.info(`매핑 템플릿 ${result.rows.length}개 조회`, { tableName });
      return result.rows;
    } catch (error: any) {
      logger.error(`매핑 템플릿 목록 조회 실패: ${error.message}`, { error });
      throw error;
    }
  }
  /**
   * 매핑 템플릿 삭제
   */
  async deleteMappingTemplate(
    id: number,
    companyCode: string
  ): Promise<boolean> {
    try {
      logger.info("매핑 템플릿 삭제", { id, companyCode });
      const pool = getPool();
      let query: string;
      let params: any[];
      if (companyCode === "*") {
        query = `DELETE FROM excel_mapping_template WHERE id = $1`;
        params = [id];
      } else {
        query = `DELETE FROM excel_mapping_template WHERE id = $1 AND company_code = $2`;
        params = [id, companyCode];
      }
      const result = await pool.query(query, params);
      if (result.rowCount && result.rowCount > 0) {
        logger.info("매핑 템플릿 삭제 완료", { id });
        return true;
      }
      logger.warn("삭제할 매핑 템플릿 없음", { id, companyCode });
      return false;
    } catch (error: any) {
      logger.error(`매핑 템플릿 삭제 실패: ${error.message}`, { error });
      throw error;
    }
  }
 }
 export default new ExcelMappingService();
--- a/backend-node/src/services/masterDetailExcelService.ts
+++ b/backend-node/src/services/masterDetailExcelService.ts
@ -1,908 +0,0 @@
 /**
 * 마스터-디테일 엑셀 처리 서비스
 * 
 * 분할 패널 화면의 마스터-디테일 구조를 자동 감지하고
 * 엑셀 다운로드/업로드 시 JOIN 및 그룹화 처리를 수행합니다.
 */
 import { query, queryOne, transaction, getPool } from "../database/db";
 import { logger } from "../utils/logger";
 // ================================
 // 인터페이스 정의
 // ================================
 /**
 * 마스터-디테일 관계 정보
 */
 export interface MasterDetailRelation {
  masterTable: string;
  detailTable: string;
  masterKeyColumn: string;  // 마스터 테이블의 키 컬럼 (예: order_no)
  detailFkColumn: string;   // 디테일 테이블의 FK 컬럼 (예: order_no)
  masterColumns: ColumnInfo[];
  detailColumns: ColumnInfo[];
 }
 /**
 * 컬럼 정보
 */
 export interface ColumnInfo {
  name: string;
  label: string;
  inputType: string;
  isFromMaster: boolean;
 }
 /**
 * 분할 패널 설정
 */
 export interface SplitPanelConfig {
  leftPanel: {
    tableName: string;
    columns: Array<{ name: string; label: string; width?: number }>;
  };
  rightPanel: {
    tableName: string;
    columns: Array<{ name: string; label: string; width?: number }>;
    relation?: {
      type: string;
      foreignKey?: string;
      leftColumn?: string;
      // 복합키 지원 (새로운 방식)
      keys?: Array<{
        leftColumn: string;
        rightColumn: string;
      }>;
    };
  };
 }
 /**
 * 엑셀 다운로드 결과
 */
 export interface ExcelDownloadData {
  headers: string[];       // 컬럼 라벨들
  columns: string[];       // 컬럼명들
  data: Record<string, any>[];
  masterColumns: string[]; // 마스터 컬럼 목록
  detailColumns: string[]; // 디테일 컬럼 목록
  joinKey: string;         // 조인 키
 }
 /**
 * 엑셀 업로드 결과
 */
 export interface ExcelUploadResult {
  success: boolean;
  masterInserted: number;
  masterUpdated: number;
  detailInserted: number;
  detailDeleted: number;
  errors: string[];
 }
 // ================================
 // 서비스 클래스
 // ================================
 class MasterDetailExcelService {
  /**
   * 화면 ID로 분할 패널 설정 조회
   */
  async getSplitPanelConfig(screenId: number): Promise<SplitPanelConfig | null> {
    try {
      logger.info(`분할 패널 설정 조회: screenId=${screenId}`);
      // screen_layouts에서 split-panel-layout 컴포넌트 찾기
      const result = await queryOne<any>(
        `SELECT properties->>'componentConfig' as config
         FROM screen_layouts
         WHERE screen_id = $1
           AND component_type = 'component'
           AND properties->>'componentType' = 'split-panel-layout'
         LIMIT 1`,
        [screenId]
      );
      if (!result || !result.config) {
        logger.info(`분할 패널 없음: screenId=${screenId}`);
        return null;
      }
      const config = typeof result.config === "string" 
        ? JSON.parse(result.config) 
        : result.config;
      logger.info(`분할 패널 설정 발견:`, {
        leftTable: config.leftPanel?.tableName,
        rightTable: config.rightPanel?.tableName,
        relation: config.rightPanel?.relation,
      });
      return {
        leftPanel: config.leftPanel,
        rightPanel: config.rightPanel,
      };
    } catch (error: any) {
      logger.error(`분할 패널 설정 조회 실패: ${error.message}`);
      return null;
    }
  }
  /**
   * column_labels에서 Entity 관계 정보 조회
   * 디테일 테이블에서 마스터 테이블을 참조하는 컬럼 찾기
   */
  async getEntityRelation(
    detailTable: string,
    masterTable: string
  ): Promise<{ detailFkColumn: string; masterKeyColumn: string } | null> {
    try {
      logger.info(`Entity 관계 조회: ${detailTable} -> ${masterTable}`);
      const result = await queryOne<any>(
        `SELECT column_name, reference_column
         FROM column_labels
         WHERE table_name = $1
           AND input_type = 'entity'
           AND reference_table = $2
         LIMIT 1`,
        [detailTable, masterTable]
      );
      if (!result) {
        logger.warn(`Entity 관계 없음: ${detailTable} -> ${masterTable}`);
        return null;
      }
      logger.info(`Entity 관계 발견: ${detailTable}.${result.column_name} -> ${masterTable}.${result.reference_column}`);
      return {
        detailFkColumn: result.column_name,
        masterKeyColumn: result.reference_column,
      };
    } catch (error: any) {
      logger.error(`Entity 관계 조회 실패: ${error.message}`);
      return null;
    }
  }
  /**
   * 테이블의 컬럼 라벨 정보 조회
   */
  async getColumnLabels(tableName: string): Promise<Map<string, string>> {
    try {
      const result = await query<any>(
        `SELECT column_name, column_label
         FROM column_labels
         WHERE table_name = $1`,
        [tableName]
      );
      const labelMap = new Map<string, string>();
      for (const row of result) {
        labelMap.set(row.column_name, row.column_label || row.column_name);
      }
      return labelMap;
    } catch (error: any) {
      logger.error(`컬럼 라벨 조회 실패: ${error.message}`);
      return new Map();
    }
  }
  /**
   * 마스터-디테일 관계 정보 조합
   */
  async getMasterDetailRelation(
    screenId: number
  ): Promise<MasterDetailRelation | null> {
    try {
      // 1. 분할 패널 설정 조회
      const splitPanel = await this.getSplitPanelConfig(screenId);
      if (!splitPanel) {
        return null;
      }
      const masterTable = splitPanel.leftPanel.tableName;
      const detailTable = splitPanel.rightPanel.tableName;
      if (!masterTable || !detailTable) {
        logger.warn("마스터 또는 디테일 테이블명 없음");
        return null;
      }
      // 2. 분할 패널의 relation 정보가 있으면 우선 사용
      // 🔥 keys 배열을 우선 사용 (새로운 복합키 지원 방식)
      let masterKeyColumn: string | undefined;
      let detailFkColumn: string | undefined;
      const relationKeys = splitPanel.rightPanel.relation?.keys;
      if (relationKeys && relationKeys.length > 0) {
        // keys 배열에서 첫 번째 키 사용
        masterKeyColumn = relationKeys[0].leftColumn;
        detailFkColumn = relationKeys[0].rightColumn;
        logger.info(`keys 배열에서 관계 정보 사용: ${masterKeyColumn} -> ${detailFkColumn}`);
      } else {
        // 하위 호환성: 기존 leftColumn/foreignKey 사용
        masterKeyColumn = splitPanel.rightPanel.relation?.leftColumn;
        detailFkColumn = splitPanel.rightPanel.relation?.foreignKey;
      }
      // 3. relation 정보가 없으면 column_labels에서 Entity 관계 조회
      if (!masterKeyColumn || !detailFkColumn) {
        const entityRelation = await this.getEntityRelation(detailTable, masterTable);
        if (entityRelation) {
          masterKeyColumn = entityRelation.masterKeyColumn;
          detailFkColumn = entityRelation.detailFkColumn;
        }
      }
      if (!masterKeyColumn || !detailFkColumn) {
        logger.warn("조인 키 정보를 찾을 수 없음");
        return null;
      }
      // 4. 컬럼 라벨 정보 조회
      const masterLabels = await this.getColumnLabels(masterTable);
      const detailLabels = await this.getColumnLabels(detailTable);
      // 5. 마스터 컬럼 정보 구성
      const masterColumns: ColumnInfo[] = splitPanel.leftPanel.columns.map(col => ({
        name: col.name,
        label: masterLabels.get(col.name) || col.label || col.name,
        inputType: "text",
        isFromMaster: true,
      }));
      // 6. 디테일 컬럼 정보 구성 (FK 컬럼 제외)
      const detailColumns: ColumnInfo[] = splitPanel.rightPanel.columns
        .filter(col => col.name !== detailFkColumn) // FK 컬럼 제외
        .map(col => ({
          name: col.name,
          label: detailLabels.get(col.name) || col.label || col.name,
          inputType: "text",
          isFromMaster: false,
        }));
      logger.info(`마스터-디테일 관계 구성 완료:`, {
        masterTable,
        detailTable,
        masterKeyColumn,
        detailFkColumn,
        masterColumnCount: masterColumns.length,
        detailColumnCount: detailColumns.length,
      });
      return {
        masterTable,
        detailTable,
        masterKeyColumn,
        detailFkColumn,
        masterColumns,
        detailColumns,
      };
    } catch (error: any) {
      logger.error(`마스터-디테일 관계 조회 실패: ${error.message}`);
      return null;
    }
  }
  /**
   * 마스터-디테일 JOIN 데이터 조회 (엑셀 다운로드용)
   */
  async getJoinedData(
    relation: MasterDetailRelation,
    companyCode: string,
    filters?: Record<string, any>
  ): Promise<ExcelDownloadData> {
    try {
      const { masterTable, detailTable, masterKeyColumn, detailFkColumn, masterColumns, detailColumns } = relation;
      // 조인 컬럼과 일반 컬럼 분리
      // 조인 컬럼 형식: "테이블명.컬럼명" (예: customer_mng.customer_name)
      const entityJoins: Array<{
        refTable: string;
        refColumn: string;
        sourceColumn: string;
        alias: string;
        displayColumn: string;
      }> = [];
      // SELECT 절 구성
      const selectParts: string[] = [];
      let aliasIndex = 0;
      // 마스터 컬럼 처리
      for (const col of masterColumns) {
        if (col.name.includes(".")) {
          // 조인 컬럼: 테이블명.컬럼명
          const [refTable, displayColumn] = col.name.split(".");
          const alias = `ej${aliasIndex++}`;
          // column_labels에서 FK 컬럼 찾기
          const fkColumn = await this.findForeignKeyColumn(masterTable, refTable);
          if (fkColumn) {
            entityJoins.push({
              refTable,
              refColumn: fkColumn.referenceColumn,
              sourceColumn: fkColumn.sourceColumn,
              alias,
              displayColumn,
            });
            selectParts.push(`${alias}."${displayColumn}" AS "${col.name}"`);
          } else {
            // FK를 못 찾으면 NULL로 처리
            selectParts.push(`NULL AS "${col.name}"`);
          }
        } else {
          // 일반 컬럼
          selectParts.push(`m."${col.name}"`);
        }
      }
      // 디테일 컬럼 처리
      for (const col of detailColumns) {
        if (col.name.includes(".")) {
          // 조인 컬럼: 테이블명.컬럼명
          const [refTable, displayColumn] = col.name.split(".");
          const alias = `ej${aliasIndex++}`;
          // column_labels에서 FK 컬럼 찾기
          const fkColumn = await this.findForeignKeyColumn(detailTable, refTable);
          if (fkColumn) {
            entityJoins.push({
              refTable,
              refColumn: fkColumn.referenceColumn,
              sourceColumn: fkColumn.sourceColumn,
              alias,
              displayColumn,
            });
            selectParts.push(`${alias}."${displayColumn}" AS "${col.name}"`);
          } else {
            selectParts.push(`NULL AS "${col.name}"`);
          }
        } else {
          // 일반 컬럼
          selectParts.push(`d."${col.name}"`);
        }
      }
      const selectClause = selectParts.join(", ");
      // 엔티티 조인 절 구성
      const entityJoinClauses = entityJoins.map(ej => 
        `LEFT JOIN "${ej.refTable}" ${ej.alias} ON m."${ej.sourceColumn}" = ${ej.alias}."${ej.refColumn}"`
      ).join("\n        ");
      // WHERE 절 구성
      const whereConditions: string[] = [];
      const params: any[] = [];
      let paramIndex = 1;
      // 회사 코드 필터 (최고 관리자 제외)
      if (companyCode && companyCode !== "*") {
        whereConditions.push(`m.company_code = $${paramIndex}`);
        params.push(companyCode);
        paramIndex++;
      }
      // 추가 필터 적용
      if (filters) {
        for (const [key, value] of Object.entries(filters)) {
          if (value !== undefined && value !== null && value !== "") {
            // 조인 컬럼인지 확인
            if (key.includes(".")) continue;
            // 마스터 테이블 컬럼인지 확인
            const isMasterCol = masterColumns.some(c => c.name === key);
            const tableAlias = isMasterCol ? "m" : "d";
            whereConditions.push(`${tableAlias}."${key}" = $${paramIndex}`);
            params.push(value);
            paramIndex++;
          }
        }
      }
      const whereClause = whereConditions.length > 0 
        ? `WHERE ${whereConditions.join(" AND ")}` 
        : "";
      // JOIN 쿼리 실행
      const sql = `
        SELECT ${selectClause}
        FROM "${masterTable}" m
        LEFT JOIN "${detailTable}" d 
          ON m."${masterKeyColumn}" = d."${detailFkColumn}"
          AND m.company_code = d.company_code
        ${entityJoinClauses}
        ${whereClause}
        ORDER BY m."${masterKeyColumn}", d.id
      `;
      logger.info(`마스터-디테일 JOIN 쿼리:`, { sql, params });
      const data = await query<any>(sql, params);
      // 헤더 및 컬럼 정보 구성
      const headers = [...masterColumns.map(c => c.label), ...detailColumns.map(c => c.label)];
      const columns = [...masterColumns.map(c => c.name), ...detailColumns.map(c => c.name)];
      logger.info(`마스터-디테일 데이터 조회 완료: ${data.length}행`);
      return {
        headers,
        columns,
        data,
        masterColumns: masterColumns.map(c => c.name),
        detailColumns: detailColumns.map(c => c.name),
        joinKey: masterKeyColumn,
      };
    } catch (error: any) {
      logger.error(`마스터-디테일 데이터 조회 실패: ${error.message}`);
      throw error;
    }
  }
  /**
   * 특정 테이블에서 참조 테이블로의 FK 컬럼 찾기
   */
  private async findForeignKeyColumn(
    sourceTable: string,
    referenceTable: string
  ): Promise<{ sourceColumn: string; referenceColumn: string } | null> {
    try {
      const result = await query<{ column_name: string; reference_column: string }>(
        `SELECT column_name, reference_column 
         FROM column_labels 
         WHERE table_name = $1 
         AND reference_table = $2 
         AND input_type = 'entity'
         LIMIT 1`,
        [sourceTable, referenceTable]
      );
      if (result.length > 0) {
        return {
          sourceColumn: result[0].column_name,
          referenceColumn: result[0].reference_column,
        };
      }
      return null;
    } catch (error) {
      logger.error(`FK 컬럼 조회 실패: ${sourceTable} -> ${referenceTable}`, error);
      return null;
    }
  }
  /**
   * 마스터-디테일 데이터 업로드 (엑셀 업로드용)
   * 
   * 처리 로직:
   * 1. 엑셀 데이터를 마스터 키로 그룹화
   * 2. 각 그룹의 첫 번째 행에서 마스터 데이터 추출 → UPSERT
   * 3. 해당 마스터 키의 기존 디테일 삭제
   * 4. 새 디테일 데이터 INSERT
   */
  async uploadJoinedData(
    relation: MasterDetailRelation,
    data: Record<string, any>[],
    companyCode: string,
    userId?: string
  ): Promise<ExcelUploadResult> {
    const result: ExcelUploadResult = {
      success: false,
      masterInserted: 0,
      masterUpdated: 0,
      detailInserted: 0,
      detailDeleted: 0,
      errors: [],
    };
    const pool = getPool();
    const client = await pool.connect();
    try {
      await client.query("BEGIN");
      const { masterTable, detailTable, masterKeyColumn, detailFkColumn, masterColumns, detailColumns } = relation;
      // 1. 데이터를 마스터 키로 그룹화
      const groupedData = new Map<string, Record<string, any>[]>();
      for (const row of data) {
        const masterKey = row[masterKeyColumn];
        if (!masterKey) {
          result.errors.push(`마스터 키(${masterKeyColumn}) 값이 없는 행이 있습니다.`);
          continue;
        }
        if (!groupedData.has(masterKey)) {
          groupedData.set(masterKey, []);
        }
        groupedData.get(masterKey)!.push(row);
      }
      logger.info(`데이터 그룹화 완료: ${groupedData.size}개 마스터 그룹`);
      // 2. 각 그룹 처리
      for (const [masterKey, rows] of groupedData.entries()) {
        try {
          // 2a. 마스터 데이터 추출 (첫 번째 행에서)
          const masterData: Record<string, any> = {};
          for (const col of masterColumns) {
            if (rows[0][col.name] !== undefined) {
              masterData[col.name] = rows[0][col.name];
            }
          }
          // 회사 코드, 작성자 추가
          masterData.company_code = companyCode;
          if (userId) {
            masterData.writer = userId;
          }
          // 2b. 마스터 UPSERT
          const existingMaster = await client.query(
            `SELECT id FROM "${masterTable}" WHERE "${masterKeyColumn}" = $1 AND company_code = $2`,
            [masterKey, companyCode]
          );
          if (existingMaster.rows.length > 0) {
            // UPDATE
            const updateCols = Object.keys(masterData)
              .filter(k => k !== masterKeyColumn && k !== "id")
              .map((k, i) => `"${k}" = $${i + 1}`);
            const updateValues = Object.keys(masterData)
              .filter(k => k !== masterKeyColumn && k !== "id")
              .map(k => masterData[k]);
            if (updateCols.length > 0) {
              await client.query(
                `UPDATE "${masterTable}" 
                 SET ${updateCols.join(", ")}, updated_date = NOW()
                 WHERE "${masterKeyColumn}" = $${updateValues.length + 1} AND company_code = $${updateValues.length + 2}`,
                [...updateValues, masterKey, companyCode]
              );
            }
            result.masterUpdated++;
          } else {
            // INSERT
            const insertCols = Object.keys(masterData);
            const insertPlaceholders = insertCols.map((_, i) => `$${i + 1}`);
            const insertValues = insertCols.map(k => masterData[k]);
            await client.query(
              `INSERT INTO "${masterTable}" (${insertCols.map(c => `"${c}"`).join(", ")}, created_date)
               VALUES (${insertPlaceholders.join(", ")}, NOW())`,
              insertValues
            );
            result.masterInserted++;
          }
          // 2c. 기존 디테일 삭제
          const deleteResult = await client.query(
            `DELETE FROM "${detailTable}" WHERE "${detailFkColumn}" = $1 AND company_code = $2`,
            [masterKey, companyCode]
          );
          result.detailDeleted += deleteResult.rowCount || 0;
          // 2d. 새 디테일 INSERT
          for (const row of rows) {
            const detailData: Record<string, any> = {};
            // FK 컬럼 추가
            detailData[detailFkColumn] = masterKey;
            detailData.company_code = companyCode;
            if (userId) {
              detailData.writer = userId;
            }
            // 디테일 컬럼 데이터 추출
            for (const col of detailColumns) {
              if (row[col.name] !== undefined) {
                detailData[col.name] = row[col.name];
              }
            }
            const insertCols = Object.keys(detailData);
            const insertPlaceholders = insertCols.map((_, i) => `$${i + 1}`);
            const insertValues = insertCols.map(k => detailData[k]);
            await client.query(
              `INSERT INTO "${detailTable}" (${insertCols.map(c => `"${c}"`).join(", ")}, created_date)
               VALUES (${insertPlaceholders.join(", ")}, NOW())`,
              insertValues
            );
            result.detailInserted++;
          }
        } catch (error: any) {
          result.errors.push(`마스터 키 ${masterKey} 처리 실패: ${error.message}`);
          logger.error(`마스터 키 ${masterKey} 처리 실패:`, error);
        }
      }
      await client.query("COMMIT");
      result.success = result.errors.length === 0 || result.masterInserted + result.masterUpdated > 0;
      logger.info(`마스터-디테일 업로드 완료:`, {
        masterInserted: result.masterInserted,
        masterUpdated: result.masterUpdated,
        detailInserted: result.detailInserted,
        detailDeleted: result.detailDeleted,
        errors: result.errors.length,
      });
    } catch (error: any) {
      await client.query("ROLLBACK");
      result.errors.push(`트랜잭션 실패: ${error.message}`);
      logger.error(`마스터-디테일 업로드 트랜잭션 실패:`, error);
    } finally {
      client.release();
    }
    return result;
  }
  /**
   * 마스터-디테일 간단 모드 업로드
   * 
   * 마스터 정보는 UI에서 선택하고, 엑셀은 디테일 데이터만 포함
   * 채번 규칙을 통해 마스터 키 자동 생성
   * 
   * @param screenId 화면 ID
   * @param detailData 디테일 데이터 배열
   * @param masterFieldValues UI에서 선택한 마스터 필드 값
   * @param numberingRuleId 채번 규칙 ID (optional)
   * @param companyCode 회사 코드
   * @param userId 사용자 ID
   * @param afterUploadFlowId 업로드 후 실행할 노드 플로우 ID (optional, 하위 호환성)
   * @param afterUploadFlows 업로드 후 실행할 노드 플로우 배열 (optional)
   */
  async uploadSimple(
    screenId: number,
    detailData: Record<string, any>[],
    masterFieldValues: Record<string, any>,
    numberingRuleId: string | undefined,
    companyCode: string,
    userId: string,
    afterUploadFlowId?: string,
    afterUploadFlows?: Array<{ flowId: string; order: number }>
  ): Promise<{
    success: boolean;
    masterInserted: number;
    detailInserted: number;
    generatedKey: string;
    errors: string[];
    controlResult?: any;
  }> {
    const result: {
      success: boolean;
      masterInserted: number;
      detailInserted: number;
      generatedKey: string;
      errors: string[];
      controlResult?: any;
    } = {
      success: false,
      masterInserted: 0,
      detailInserted: 0,
      generatedKey: "",
      errors: [] as string[],
    };
    const pool = getPool();
    const client = await pool.connect();
    try {
      await client.query("BEGIN");
      // 1. 마스터-디테일 관계 정보 조회
      const relation = await this.getMasterDetailRelation(screenId);
      if (!relation) {
        throw new Error("마스터-디테일 관계 정보를 찾을 수 없습니다.");
      }
      const { masterTable, detailTable, masterKeyColumn, detailFkColumn } = relation;
      // 2. 채번 처리
      let generatedKey: string;
      if (numberingRuleId) {
        // 채번 규칙으로 키 생성
        generatedKey = await this.generateNumberWithRule(client, numberingRuleId, companyCode);
      } else {
        // 채번 규칙 없으면 마스터 필드에서 키 값 사용
        generatedKey = masterFieldValues[masterKeyColumn];
        if (!generatedKey) {
          throw new Error(`마스터 키(${masterKeyColumn}) 값이 필요합니다.`);
        }
      }
      result.generatedKey = generatedKey;
      logger.info(`채번 결과: ${generatedKey}`);
      // 3. 마스터 레코드 생성
      const masterData: Record<string, any> = {
        ...masterFieldValues,
        [masterKeyColumn]: generatedKey,
        company_code: companyCode,
        writer: userId,
      };
      // 마스터 컬럼명 목록 구성
      const masterCols = Object.keys(masterData).filter(k => masterData[k] !== undefined);
      const masterPlaceholders = masterCols.map((_, i) => `$${i + 1}`);
      const masterValues = masterCols.map(k => masterData[k]);
      await client.query(
        `INSERT INTO "${masterTable}" (${masterCols.map(c => `"${c}"`).join(", ")}, created_date)
         VALUES (${masterPlaceholders.join(", ")}, NOW())`,
        masterValues
      );
      result.masterInserted = 1;
      logger.info(`마스터 레코드 생성: ${masterTable}, key=${generatedKey}`);
      // 4. 디테일 레코드들 생성 (삽입된 데이터 수집)
      const insertedDetailRows: Record<string, any>[] = [];
      for (const row of detailData) {
        try {
          const detailRowData: Record<string, any> = {
            ...row,
            [detailFkColumn]: generatedKey,
            company_code: companyCode,
            writer: userId,
          };
          // 빈 값 필터링 및 id 제외
          const detailCols = Object.keys(detailRowData).filter(k => 
            k !== "id" && 
            detailRowData[k] !== undefined && 
            detailRowData[k] !== null && 
            detailRowData[k] !== ""
          );
          const detailPlaceholders = detailCols.map((_, i) => `$${i + 1}`);
          const detailValues = detailCols.map(k => detailRowData[k]);
          // RETURNING *로 삽입된 데이터 반환받기
          const insertResult = await client.query(
            `INSERT INTO "${detailTable}" (${detailCols.map(c => `"${c}"`).join(", ")}, created_date)
             VALUES (${detailPlaceholders.join(", ")}, NOW())
             RETURNING *`,
            detailValues
          );
          if (insertResult.rows && insertResult.rows[0]) {
            insertedDetailRows.push(insertResult.rows[0]);
          }
          result.detailInserted++;
        } catch (error: any) {
          result.errors.push(`디테일 행 처리 실패: ${error.message}`);
          logger.error(`디테일 행 처리 실패:`, error);
        }
      }
      logger.info(`디테일 레코드 ${insertedDetailRows.length}건 삽입 완료`);
      await client.query("COMMIT");
      result.success = result.errors.length === 0 || result.detailInserted > 0;
      logger.info(`마스터-디테일 간단 모드 업로드 완료:`, {
        masterInserted: result.masterInserted,
        detailInserted: result.detailInserted,
        generatedKey: result.generatedKey,
        errors: result.errors.length,
      });
      // 업로드 후 제어 실행 (단일 또는 다중)
      const flowsToExecute = afterUploadFlows && afterUploadFlows.length > 0
        ? afterUploadFlows // 다중 제어
        : afterUploadFlowId 
          ? [{ flowId: afterUploadFlowId, order: 1 }] // 단일 (하위 호환성)
          : [];
      if (flowsToExecute.length > 0 && result.success) {
        try {
          const { NodeFlowExecutionService } = await import("./nodeFlowExecutionService");
          // 마스터 데이터 구성
          const masterData = {
            ...masterFieldValues,
            [relation!.masterKeyColumn]: result.generatedKey,
            company_code: companyCode,
          };
          const controlResults: any[] = [];
          // 순서대로 제어 실행
          for (const flow of flowsToExecute.sort((a, b) => a.order - b.order)) {
            logger.info(`업로드 후 제어 실행: flowId=${flow.flowId}, order=${flow.order}`);
            logger.info(`   전달 데이터: 마스터 1건, 디테일 ${insertedDetailRows.length}건`);
            // 🆕 삽입된 디테일 데이터를 sourceData로 전달 (성능 최적화)
            // - 전체 테이블 조회 대신 방금 INSERT한 데이터만 처리
            // - tableSource 노드가 context-data 모드일 때 이 데이터를 사용
            const controlResult = await NodeFlowExecutionService.executeFlow(
              parseInt(flow.flowId),
              {
                sourceData: insertedDetailRows.length > 0 ? insertedDetailRows : [masterData],
                dataSourceType: "excelUpload", // 엑셀 업로드 데이터임을 명시
                buttonId: "excel-upload-button",
                screenId: screenId,
                userId: userId,
                companyCode: companyCode,
                formData: masterData,
                // 추가 컨텍스트: 마스터/디테일 정보
                masterData: masterData,
                detailData: insertedDetailRows,
                masterTable: relation!.masterTable,
                detailTable: relation!.detailTable,
                masterKeyColumn: relation!.masterKeyColumn,
                detailFkColumn: relation!.detailFkColumn,
              }
            );
            controlResults.push({
              flowId: flow.flowId,
              order: flow.order,
              success: controlResult.success,
              message: controlResult.message,
              executedNodes: controlResult.nodes?.length || 0,
            });
          }
          result.controlResult = {
            success: controlResults.every(r => r.success),
            executedFlows: controlResults.length,
            results: controlResults,
          };
          logger.info(`업로드 후 제어 실행 완료: ${controlResults.length}개 실행`, result.controlResult);
        } catch (controlError: any) {
          logger.error(`업로드 후 제어 실행 실패:`, controlError);
          result.controlResult = {
            success: false,
            message: `제어 실행 실패: ${controlError.message}`,
          };
        }
      }
    } catch (error: any) {
      await client.query("ROLLBACK");
      result.errors.push(`트랜잭션 실패: ${error.message}`);
      logger.error(`마스터-디테일 간단 모드 업로드 실패:`, error);
    } finally {
      client.release();
    }
    return result;
  }
  /**
   * 채번 규칙으로 번호 생성 (기존 numberingRuleService 사용)
   */
  private async generateNumberWithRule(
    client: any, 
    ruleId: string, 
    companyCode: string
  ): Promise<string> {
    try {
      // 기존 numberingRuleService를 사용하여 코드 할당
      const { numberingRuleService } = await import("./numberingRuleService");
      const generatedCode = await numberingRuleService.allocateCode(ruleId, companyCode);
      logger.info(`채번 생성 (numberingRuleService): rule=${ruleId}, result=${generatedCode}`);
      return generatedCode;
    } catch (error: any) {
      logger.error(`채번 생성 실패: rule=${ruleId}, error=${error.message}`);
      throw error;
    }
  }
 }
 export const masterDetailExcelService = new MasterDetailExcelService();
--- a/backend-node/src/services/menuCopyService.ts
+++ b/backend-node/src/services/menuCopyService.ts
@ -2090,7 +2090,7 @@ export class MenuCopyService {
            menu.menu_url,
            menu.menu_desc,
            userId,
-            'active', // 복제된 메뉴는 항상 활성화 상태
+            menu.status,
            menu.system_name,
            targetCompanyCode, // 새 회사 코드
            menu.lang_key,
--- a/backend-node/src/services/menuScreenSyncService.ts
+++ b/backend-node/src/services/menuScreenSyncService.ts
@ -1,969 +0,0 @@
 import { getPool } from "../database/db";
 import { logger } from "../utils/logger";
 const pool = getPool();
 /**
 * 메뉴-화면그룹 동기화 서비스
 * 
 * 양방향 동기화:
 * 1. screen_groups → menu_info: 화면관리 폴더 구조를 메뉴로 동기화
 * 2. menu_info → screen_groups: 사용자 메뉴를 화면관리 폴더로 동기화
 */
 // ============================================================
 // 타입 정의
 // ============================================================
 interface SyncResult {
  success: boolean;
  created: number;
  linked: number;
  skipped: number;
  errors: string[];
  details: SyncDetail[];
 }
 interface SyncDetail {
  action: 'created' | 'linked' | 'skipped' | 'error';
  sourceName: string;
  sourceId: number | string;
  targetId?: number | string;
  reason?: string;
 }
 // ============================================================
 // 화면관리 → 메뉴 동기화
 // ============================================================
 /**
 * screen_groups를 menu_info로 동기화
 * 
 * 로직:
 * 1. 해당 회사의 screen_groups 조회 (폴더 구조)
 * 2. 이미 menu_objid가 연결된 것은 제외
 * 3. 이름으로 기존 menu_info 매칭 시도
 *    - 매칭되면: 양쪽에 연결 ID 업데이트
 *    - 매칭 안되면: menu_info에 새로 생성
 * 4. 계층 구조(parent) 유지
 */
 export async function syncScreenGroupsToMenu(
  companyCode: string,
  userId: string
 ): Promise<SyncResult> {
  const result: SyncResult = {
    success: true,
    created: 0,
    linked: 0,
    skipped: 0,
    errors: [],
    details: [],
  };
  const client = await pool.connect();
  try {
    await client.query('BEGIN');
    logger.info("화면관리 → 메뉴 동기화 시작", { companyCode, userId });
    // 1. 해당 회사의 screen_groups 조회 (아직 menu_objid가 없는 것)
    const screenGroupsQuery = `
      SELECT 
        sg.id, 
        sg.group_name, 
        sg.group_code, 
        sg.parent_group_id,
        sg.group_level,
        sg.display_order,
        sg.description,
        sg.icon,
        sg.menu_objid,
        -- 부모 그룹의 menu_objid도 조회 (계층 연결용)
        parent.menu_objid as parent_menu_objid
      FROM screen_groups sg
      LEFT JOIN screen_groups parent ON sg.parent_group_id = parent.id
      WHERE sg.company_code = $1
      ORDER BY sg.group_level ASC, sg.display_order ASC
    `;
    const screenGroupsResult = await client.query(screenGroupsQuery, [companyCode]);
    // 2. 해당 회사의 기존 menu_info 조회 (사용자 메뉴, menu_type=1)
    // 경로 기반 매칭을 위해 부모 이름도 조회
    const existingMenusQuery = `
      SELECT 
        m.objid, 
        m.menu_name_kor, 
        m.parent_obj_id, 
        m.screen_group_id,
        p.menu_name_kor as parent_name
      FROM menu_info m
      LEFT JOIN menu_info p ON m.parent_obj_id = p.objid
      WHERE m.company_code = $1 AND m.menu_type = 1
    `;
    const existingMenusResult = await client.query(existingMenusQuery, [companyCode]);
    // 경로(부모이름 > 이름) → 메뉴 매핑 (screen_group_id가 없는 것만)
    // 단순 이름 매칭도 유지 (하위 호환)
    const menuByPath: Map<string, any> = new Map();
    const menuByName: Map<string, any> = new Map();
    existingMenusResult.rows.forEach((menu: any) => {
      if (!menu.screen_group_id) {
        const menuName = menu.menu_name_kor?.trim().toLowerCase() || '';
        const parentName = menu.parent_name?.trim().toLowerCase() || '';
        const pathKey = parentName ? `${parentName}>${menuName}` : menuName;
        menuByPath.set(pathKey, menu);
        // 단순 이름 매핑은 첫 번째 것만 (중복 방지)
        if (!menuByName.has(menuName)) {
          menuByName.set(menuName, menu);
        }
      }
    });
    // 모든 메뉴의 objid 집합 (삭제 확인용)
    const existingMenuObjids = new Set(existingMenusResult.rows.map((m: any) => Number(m.objid)));
    // 3. 사용자 메뉴의 루트 찾기 (parent_obj_id = 0인 사용자 메뉴)
    // 없으면 생성
    let userMenuRootObjid: number | null = null;
    const rootMenuQuery = `
      SELECT objid FROM menu_info 
      WHERE company_code = $1 AND menu_type = 1 AND parent_obj_id = 0
      ORDER BY seq ASC
      LIMIT 1
    `;
    const rootMenuResult = await client.query(rootMenuQuery, [companyCode]);
    if (rootMenuResult.rows.length > 0) {
      userMenuRootObjid = Number(rootMenuResult.rows[0].objid);
    } else {
      // 루트 메뉴가 없으면 생성
      const newObjid = Date.now();
      const createRootQuery = `
        INSERT INTO menu_info (objid, parent_obj_id, menu_name_kor, menu_name_eng, seq, menu_type, company_code, writer, regdate, status)
        VALUES ($1, 0, '사용자', 'User', 1, 1, $2, $3, NOW(), 'active')
        RETURNING objid
      `;
      const createRootResult = await client.query(createRootQuery, [newObjid, companyCode, userId]);
      userMenuRootObjid = Number(createRootResult.rows[0].objid);
      logger.info("사용자 메뉴 루트 생성", { companyCode, objid: userMenuRootObjid });
    }
    // 4. screen_groups ID → menu_objid 매핑 (순차 처리를 위해)
    const groupToMenuMap: Map<number, number> = new Map();
    // screen_groups의 부모 이름 조회를 위한 매핑
    const groupIdToName: Map<number, string> = new Map();
    screenGroupsResult.rows.forEach((g: any) => {
      groupIdToName.set(g.id, g.group_name?.trim().toLowerCase() || '');
    });
    // 5. 최상위 회사 폴더 ID 찾기 (level 0, parent_group_id IS NULL)
    // 이 폴더는 메뉴로 생성하지 않고, 하위 폴더들을 사용자 루트 바로 아래에 배치
    const topLevelCompanyFolderIds = new Set<number>();
    for (const group of screenGroupsResult.rows) {
      if (group.group_level === 0 && group.parent_group_id === null) {
        topLevelCompanyFolderIds.add(group.id);
        // 최상위 폴더 → 사용자 루트에 매핑 (하위 폴더의 부모로 사용)
        groupToMenuMap.set(group.id, userMenuRootObjid!);
        logger.info("최상위 회사 폴더 스킵", { groupId: group.id, groupName: group.group_name });
      }
    }
    // 6. 각 screen_group 처리
    for (const group of screenGroupsResult.rows) {
      const groupId = group.id;
      const groupName = group.group_name?.trim();
      const groupNameLower = groupName?.toLowerCase() || '';
      // 최상위 회사 폴더는 메뉴로 생성하지 않고 스킵
      if (topLevelCompanyFolderIds.has(groupId)) {
        result.skipped++;
        result.details.push({
          action: 'skipped',
          sourceName: groupName,
          sourceId: groupId,
          reason: '최상위 회사 폴더 (메뉴 생성 스킵)',
        });
        continue;
      }
      // 이미 연결된 경우 - 실제로 메뉴가 존재하는지 확인
      if (group.menu_objid) {
        const menuExists = existingMenuObjids.has(Number(group.menu_objid));
        if (menuExists) {
          // 메뉴가 존재하면 스킵
          result.skipped++;
          result.details.push({
            action: 'skipped',
            sourceName: groupName,
            sourceId: groupId,
            targetId: group.menu_objid,
            reason: '이미 메뉴와 연결됨',
          });
          groupToMenuMap.set(groupId, Number(group.menu_objid));
          continue;
        } else {
          // 메뉴가 삭제되었으면 연결 해제하고 재생성
          logger.info("삭제된 메뉴 연결 해제", { groupId, deletedMenuObjid: group.menu_objid });
          await client.query(
            `UPDATE screen_groups SET menu_objid = NULL, updated_date = NOW() WHERE id = $1`,
            [groupId]
          );
          // 계속 진행하여 재생성 또는 재연결
        }
      }
      // 부모 그룹 이름 조회 (경로 기반 매칭용)
      const parentGroupName = group.parent_group_id ? groupIdToName.get(group.parent_group_id) : '';
      const pathKey = parentGroupName ? `${parentGroupName}>${groupNameLower}` : groupNameLower;
      // 경로로 기존 메뉴 매칭 시도 (우선순위: 경로 매칭 > 이름 매칭)
      let matchedMenu = menuByPath.get(pathKey);
      if (!matchedMenu) {
        // 경로 매칭 실패시 이름으로 시도 (하위 호환)
        matchedMenu = menuByName.get(groupNameLower);
      }
      if (matchedMenu) {
        // 매칭된 메뉴와 연결
        const menuObjid = Number(matchedMenu.objid);
        // screen_groups에 menu_objid 업데이트
        await client.query(
          `UPDATE screen_groups SET menu_objid = $1, updated_date = NOW() WHERE id = $2`,
          [menuObjid, groupId]
        );
        // menu_info에 screen_group_id 업데이트
        await client.query(
          `UPDATE menu_info SET screen_group_id = $1 WHERE objid = $2`,
          [groupId, menuObjid]
        );
        groupToMenuMap.set(groupId, menuObjid);
        result.linked++;
        result.details.push({
          action: 'linked',
          sourceName: groupName,
          sourceId: groupId,
          targetId: menuObjid,
        });
        // 매칭된 메뉴는 Map에서 제거 (중복 매칭 방지)
        menuByPath.delete(pathKey);
        menuByName.delete(groupNameLower);
      } else {
        // 새 메뉴 생성
        const newObjid = Date.now() + groupId; // 고유 ID 보장
        // 부모 메뉴 objid 결정
        // 우선순위: groupToMenuMap > parent_menu_objid (존재 확인 필수)
        let parentMenuObjid = userMenuRootObjid;
        if (group.parent_group_id && groupToMenuMap.has(group.parent_group_id)) {
          // 현재 트랜잭션에서 생성된 부모 메뉴 사용
          parentMenuObjid = groupToMenuMap.get(group.parent_group_id)!;
        } else if (group.parent_group_id && group.parent_menu_objid) {
          // 기존 parent_menu_objid가 실제로 존재하는지 확인
          const parentMenuExists = existingMenuObjids.has(Number(group.parent_menu_objid));
          if (parentMenuExists) {
            parentMenuObjid = Number(group.parent_menu_objid);
          }
        }
        // 같은 부모 아래에서 가장 높은 seq 조회 후 +1
        let nextSeq = 1;
        const maxSeqQuery = `
          SELECT COALESCE(MAX(seq), 0) + 1 as next_seq 
          FROM menu_info 
          WHERE parent_obj_id = $1 AND company_code = $2 AND menu_type = 1
        `;
        const maxSeqResult = await client.query(maxSeqQuery, [parentMenuObjid, companyCode]);
        if (maxSeqResult.rows.length > 0) {
          nextSeq = parseInt(maxSeqResult.rows[0].next_seq) || 1;
        }
        // menu_info에 삽입
        const insertMenuQuery = `
          INSERT INTO menu_info (
            objid, parent_obj_id, menu_name_kor, menu_name_eng, 
            seq, menu_type, company_code, writer, regdate, status, screen_group_id, menu_desc
          ) VALUES ($1, $2, $3, $4, $5, 1, $6, $7, NOW(), 'active', $8, $9)
          RETURNING objid
        `;
        await client.query(insertMenuQuery, [
          newObjid,
          parentMenuObjid,
          groupName,
          group.group_code || groupName,
          nextSeq,
          companyCode,
          userId,
          groupId,
          group.description || null,
        ]);
        // screen_groups에 menu_objid 업데이트
        await client.query(
          `UPDATE screen_groups SET menu_objid = $1, updated_date = NOW() WHERE id = $2`,
          [newObjid, groupId]
        );
        groupToMenuMap.set(groupId, newObjid);
        result.created++;
        result.details.push({
          action: 'created',
          sourceName: groupName,
          sourceId: groupId,
          targetId: newObjid,
        });
      }
    }
    await client.query('COMMIT');
    logger.info("화면관리 → 메뉴 동기화 완료", { 
      companyCode, 
      created: result.created, 
      linked: result.linked, 
      skipped: result.skipped 
    });
    return result;
  } catch (error: any) {
    await client.query('ROLLBACK');
    logger.error("화면관리 → 메뉴 동기화 실패", { companyCode, error: error.message });
    result.success = false;
    result.errors.push(error.message);
    return result;
  } finally {
    client.release();
  }
 }
 // ============================================================
 // 메뉴 → 화면관리 동기화
 // ============================================================
 /**
 * menu_info를 screen_groups로 동기화
 * 
 * 로직:
 * 1. 해당 회사의 사용자 메뉴(menu_type=1) 조회
 * 2. 이미 screen_group_id가 연결된 것은 제외
 * 3. 이름으로 기존 screen_groups 매칭 시도
 *    - 매칭되면: 양쪽에 연결 ID 업데이트
 *    - 매칭 안되면: screen_groups에 새로 생성 (폴더로)
 * 4. 계층 구조(parent) 유지
 */
 export async function syncMenuToScreenGroups(
  companyCode: string,
  userId: string
 ): Promise<SyncResult> {
  const result: SyncResult = {
    success: true,
    created: 0,
    linked: 0,
    skipped: 0,
    errors: [],
    details: [],
  };
  const client = await pool.connect();
  try {
    await client.query('BEGIN');
    logger.info("메뉴 → 화면관리 동기화 시작", { companyCode, userId });
    // 0. 회사 이름 조회 (회사 폴더 찾기/생성용)
    const companyNameQuery = `SELECT company_name FROM company_mng WHERE company_code = $1`;
    const companyNameResult = await client.query(companyNameQuery, [companyCode]);
    const companyName = companyNameResult.rows[0]?.company_name || companyCode;
    // 1. 해당 회사의 사용자 메뉴 조회 (menu_type=1)
    const menusQuery = `
      SELECT 
        m.objid, 
        m.menu_name_kor, 
        m.menu_name_eng,
        m.parent_obj_id,
        m.seq,
        m.menu_url,
        m.menu_desc,
        m.screen_group_id,
        -- 부모 메뉴의 screen_group_id도 조회 (계층 연결용)
        parent.screen_group_id as parent_screen_group_id
      FROM menu_info m
      LEFT JOIN menu_info parent ON m.parent_obj_id = parent.objid
      WHERE m.company_code = $1 AND m.menu_type = 1
      ORDER BY 
        CASE WHEN m.parent_obj_id = 0 THEN 0 ELSE 1 END,
        m.parent_obj_id,
        m.seq
    `;
    const menusResult = await client.query(menusQuery, [companyCode]);
    // 2. 해당 회사의 기존 screen_groups 조회 (경로 기반 매칭을 위해 부모 이름도 조회)
    const existingGroupsQuery = `
      SELECT 
        g.id, 
        g.group_name, 
        g.menu_objid,
        g.parent_group_id,
        p.group_name as parent_name
      FROM screen_groups g
      LEFT JOIN screen_groups p ON g.parent_group_id = p.id
      WHERE g.company_code = $1
    `;
    const existingGroupsResult = await client.query(existingGroupsQuery, [companyCode]);
    // 경로(부모이름 > 이름) → 그룹 매핑 (menu_objid가 없는 것만)
    // 단순 이름 매칭도 유지 (하위 호환)
    const groupByPath: Map<string, any> = new Map();
    const groupByName: Map<string, any> = new Map();
    existingGroupsResult.rows.forEach((group: any) => {
      if (!group.menu_objid) {
        const groupName = group.group_name?.trim().toLowerCase() || '';
        const parentName = group.parent_name?.trim().toLowerCase() || '';
        const pathKey = parentName ? `${parentName}>${groupName}` : groupName;
        groupByPath.set(pathKey, group);
        // 단순 이름 매핑은 첫 번째 것만 (중복 방지)
        if (!groupByName.has(groupName)) {
          groupByName.set(groupName, group);
        }
      }
    });
    // 모든 그룹의 id 집합 (삭제 확인용)
    const existingGroupIds = new Set(existingGroupsResult.rows.map((g: any) => Number(g.id)));
    // 3. 회사 폴더 찾기 또는 생성 (루트 레벨에 회사명으로 된 폴더)
    let companyFolderId: number | null = null;
    const companyFolderQuery = `
      SELECT id FROM screen_groups 
      WHERE company_code = $1 AND parent_group_id IS NULL AND group_level = 0
      ORDER BY id ASC
      LIMIT 1
    `;
    const companyFolderResult = await client.query(companyFolderQuery, [companyCode]);
    if (companyFolderResult.rows.length > 0) {
      companyFolderId = companyFolderResult.rows[0].id;
      logger.info("회사 폴더 발견", { companyCode, companyFolderId, companyName });
    } else {
      // 회사 폴더가 없으면 생성
      // 루트 레벨에서 가장 높은 display_order 조회 후 +1
      let nextRootOrder = 1;
      const maxRootOrderQuery = `
        SELECT COALESCE(MAX(display_order), 0) + 1 as next_order 
        FROM screen_groups 
        WHERE parent_group_id IS NULL
      `;
      const maxRootOrderResult = await client.query(maxRootOrderQuery);
      if (maxRootOrderResult.rows.length > 0) {
        nextRootOrder = parseInt(maxRootOrderResult.rows[0].next_order) || 1;
      }
      const createFolderQuery = `
        INSERT INTO screen_groups (
          group_name, group_code, parent_group_id, group_level,
          display_order, company_code, writer, hierarchy_path
        ) VALUES ($1, $2, NULL, 0, $3, $4, $5, '/')
        RETURNING id
      `;
      const createFolderResult = await client.query(createFolderQuery, [
        companyName,
        companyCode.toLowerCase(),
        nextRootOrder,
        companyCode,
        userId,
      ]);
      companyFolderId = createFolderResult.rows[0].id;
      // hierarchy_path 업데이트
      await client.query(
        `UPDATE screen_groups SET hierarchy_path = $1 WHERE id = $2`,
        [`/${companyFolderId}/`, companyFolderId]
      );
      logger.info("회사 폴더 생성", { companyCode, companyFolderId, companyName });
    }
    // 4. menu_objid → screen_group_id 매핑 (순차 처리를 위해)
    const menuToGroupMap: Map<number, number> = new Map();
    // 부모 메뉴 중 이미 screen_group_id가 있는 것 등록
    menusResult.rows.forEach((menu: any) => {
      if (menu.screen_group_id) {
        menuToGroupMap.set(Number(menu.objid), Number(menu.screen_group_id));
      }
    });
    // 루트 메뉴(parent_obj_id = 0)의 objid 찾기 → 회사 폴더와 매핑
    let rootMenuObjid: number | null = null;
    for (const menu of menusResult.rows) {
      if (Number(menu.parent_obj_id) === 0) {
        rootMenuObjid = Number(menu.objid);
        // 루트 메뉴는 회사 폴더와 연결
        if (companyFolderId) {
          menuToGroupMap.set(rootMenuObjid, companyFolderId);
        }
        break;
      }
    }
    // 5. 각 메뉴 처리
    for (const menu of menusResult.rows) {
      const menuObjid = Number(menu.objid);
      const menuName = menu.menu_name_kor?.trim();
      // 루트 메뉴(parent_obj_id = 0)는 스킵 (이미 회사 폴더와 매핑됨)
      if (Number(menu.parent_obj_id) === 0) {
        result.skipped++;
        result.details.push({
          action: 'skipped',
          sourceName: menuName,
          sourceId: menuObjid,
          targetId: companyFolderId || undefined,
          reason: '루트 메뉴 → 회사 폴더와 매핑됨',
        });
        continue;
      }
      // 이미 연결된 경우 - 실제로 그룹이 존재하는지 확인
      if (menu.screen_group_id) {
        const groupExists = existingGroupIds.has(Number(menu.screen_group_id));
        if (groupExists) {
          // 그룹이 존재하면 스킵
          result.skipped++;
          result.details.push({
            action: 'skipped',
            sourceName: menuName,
            sourceId: menuObjid,
            targetId: menu.screen_group_id,
            reason: '이미 화면그룹과 연결됨',
          });
          menuToGroupMap.set(menuObjid, Number(menu.screen_group_id));
          continue;
        } else {
          // 그룹이 삭제되었으면 연결 해제하고 재생성
          logger.info("삭제된 그룹 연결 해제", { menuObjid, deletedGroupId: menu.screen_group_id });
          await client.query(
            `UPDATE menu_info SET screen_group_id = NULL WHERE objid = $1`,
            [menuObjid]
          );
          // 계속 진행하여 재생성 또는 재연결
        }
      }
      const menuNameLower = menuName?.toLowerCase() || '';
      // 부모 메뉴 이름 조회 (경로 기반 매칭용)
      const parentMenu = menusResult.rows.find((m: any) => Number(m.objid) === Number(menu.parent_obj_id));
      const parentMenuName = parentMenu?.menu_name_kor?.trim().toLowerCase() || '';
      const pathKey = parentMenuName ? `${parentMenuName}>${menuNameLower}` : menuNameLower;
      // 경로로 기존 그룹 매칭 시도 (우선순위: 경로 매칭 > 이름 매칭)
      let matchedGroup = groupByPath.get(pathKey);
      if (!matchedGroup) {
        // 경로 매칭 실패시 이름으로 시도 (하위 호환)
        matchedGroup = groupByName.get(menuNameLower);
      }
      if (matchedGroup) {
        // 매칭된 그룹과 연결
        const groupId = Number(matchedGroup.id);
        try {
          // menu_info에 screen_group_id 업데이트
          await client.query(
            `UPDATE menu_info SET screen_group_id = $1 WHERE objid = $2`,
            [groupId, menuObjid]
          );
          // screen_groups에 menu_objid 업데이트
          await client.query(
            `UPDATE screen_groups SET menu_objid = $1, updated_date = NOW() WHERE id = $2`,
            [menuObjid, groupId]
          );
          menuToGroupMap.set(menuObjid, groupId);
          result.linked++;
          result.details.push({
            action: 'linked',
            sourceName: menuName,
            sourceId: menuObjid,
            targetId: groupId,
          });
          // 매칭된 그룹은 Map에서 제거 (중복 매칭 방지)
          groupByPath.delete(pathKey);
          groupByName.delete(menuNameLower);
        } catch (linkError: any) {
          logger.error("그룹 연결 중 에러", { menuName, menuObjid, groupId, error: linkError.message, stack: linkError.stack });
          throw linkError;
        }
      } else {
        // 새 screen_group 생성
        // 부모 그룹 ID 결정
        let parentGroupId: number | null = null;
        let groupLevel = 1; // 기본값은 1 (회사 폴더 아래)
        // 우선순위 1: menuToGroupMap에서 부모 메뉴의 새 그룹 ID 조회 (같은 트랜잭션에서 생성된 것)
        if (menuToGroupMap.has(Number(menu.parent_obj_id))) {
          parentGroupId = menuToGroupMap.get(Number(menu.parent_obj_id))!;
        }
        // 우선순위 2: 부모 메뉴가 루트 메뉴면 회사 폴더 사용
        else if (Number(menu.parent_obj_id) === rootMenuObjid) {
          parentGroupId = companyFolderId;
        }
        // 우선순위 3: 부모 메뉴의 screen_group_id가 있고, 해당 그룹이 실제로 존재하면 사용
        else if (menu.parent_screen_group_id && existingGroupIds.has(Number(menu.parent_screen_group_id))) {
          parentGroupId = Number(menu.parent_screen_group_id);
        }
        // 부모 그룹의 레벨 조회
        if (parentGroupId) {
          const parentLevelQuery = `SELECT group_level FROM screen_groups WHERE id = $1`;
          const parentLevelResult = await client.query(parentLevelQuery, [parentGroupId]);
          if (parentLevelResult.rows.length > 0) {
            groupLevel = (parentLevelResult.rows[0].group_level || 0) + 1;
          }
        }
        // 같은 부모 아래에서 가장 높은 display_order 조회 후 +1
        let nextDisplayOrder = 1;
        const maxOrderQuery = parentGroupId
          ? `SELECT COALESCE(MAX(display_order), 0) + 1 as next_order FROM screen_groups WHERE parent_group_id = $1 AND company_code = $2`
          : `SELECT COALESCE(MAX(display_order), 0) + 1 as next_order FROM screen_groups WHERE parent_group_id IS NULL AND company_code = $1`;
        const maxOrderParams = parentGroupId ? [parentGroupId, companyCode] : [companyCode];
        const maxOrderResult = await client.query(maxOrderQuery, maxOrderParams);
        if (maxOrderResult.rows.length > 0) {
          nextDisplayOrder = parseInt(maxOrderResult.rows[0].next_order) || 1;
        }
        // group_code 생성 (영문명 또는 이름 기반)
        const groupCode = (menu.menu_name_eng || menuName || 'group')
          .replace(/\s+/g, '_')
          .toLowerCase()
          .substring(0, 50);
        // screen_groups에 삽입
        const insertGroupQuery = `
          INSERT INTO screen_groups (
            group_name, group_code, parent_group_id, group_level,
            display_order, company_code, writer, menu_objid, description
          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
          RETURNING id
        `;
        let newGroupId: number;
        try {
          logger.info("새 그룹 생성 시도", { 
            menuName, 
            menuObjid, 
            groupCode: groupCode + '_' + menuObjid,
            parentGroupId, 
            groupLevel, 
            nextDisplayOrder,
            companyCode,
          });
          const insertResult = await client.query(insertGroupQuery, [
            menuName,
            groupCode + '_' + menuObjid, // 고유성 보장
            parentGroupId,
            groupLevel,
            nextDisplayOrder,
            companyCode,
            userId,
            menuObjid,
            menu.menu_desc || null,
          ]);
          newGroupId = insertResult.rows[0].id;
        } catch (insertError: any) {
          logger.error("그룹 생성 중 에러", { 
            menuName, 
            menuObjid, 
            parentGroupId, 
            groupLevel,
            error: insertError.message, 
            stack: insertError.stack,
            code: insertError.code,
            detail: insertError.detail,
          });
          throw insertError;
        }
        // hierarchy_path 업데이트
        let hierarchyPath = `/${newGroupId}/`;
        if (parentGroupId) {
          const parentPathQuery = `SELECT hierarchy_path FROM screen_groups WHERE id = $1`;
          const parentPathResult = await client.query(parentPathQuery, [parentGroupId]);
          if (parentPathResult.rows.length > 0 && parentPathResult.rows[0].hierarchy_path) {
            hierarchyPath = `${parentPathResult.rows[0].hierarchy_path}${newGroupId}/`.replace('//', '/');
          }
        }
        await client.query(
          `UPDATE screen_groups SET hierarchy_path = $1 WHERE id = $2`,
          [hierarchyPath, newGroupId]
        );
        // menu_info에 screen_group_id 업데이트
        await client.query(
          `UPDATE menu_info SET screen_group_id = $1 WHERE objid = $2`,
          [newGroupId, menuObjid]
        );
        menuToGroupMap.set(menuObjid, newGroupId);
        result.created++;
        result.details.push({
          action: 'created',
          sourceName: menuName,
          sourceId: menuObjid,
          targetId: newGroupId,
        });
      }
    }
    await client.query('COMMIT');
    logger.info("메뉴 → 화면관리 동기화 완료", { 
      companyCode, 
      created: result.created, 
      linked: result.linked, 
      skipped: result.skipped 
    });
    return result;
  } catch (error: any) {
    await client.query('ROLLBACK');
    logger.error("메뉴 → 화면관리 동기화 실패", { 
      companyCode, 
      error: error.message,
      stack: error.stack,
      code: error.code,
      detail: error.detail,
    });
    result.success = false;
    result.errors.push(error.message);
    return result;
  } finally {
    client.release();
  }
 }
 // ============================================================
 // 동기화 상태 조회
 // ============================================================
 /**
 * 동기화 상태 조회
 * 
 * - 연결된 항목 수
 * - 연결 안 된 항목 수
 * - 양방향 비교
 */
 export async function getSyncStatus(companyCode: string): Promise<{
  screenGroups: { total: number; linked: number; unlinked: number };
  menuItems: { total: number; linked: number; unlinked: number };
  potentialMatches: Array<{ menuName: string; groupName: string; similarity: string }>;
 }> {
  // screen_groups 상태
  const sgQuery = `
    SELECT 
      COUNT(*) as total,
      COUNT(menu_objid) as linked
    FROM screen_groups
    WHERE company_code = $1
  `;
  const sgResult = await pool.query(sgQuery, [companyCode]);
  // menu_info 상태 (사용자 메뉴만, 루트 제외)
  const menuQuery = `
    SELECT 
      COUNT(*) as total,
      COUNT(screen_group_id) as linked
    FROM menu_info
    WHERE company_code = $1 AND menu_type = 1 AND parent_obj_id != 0
  `;
  const menuResult = await pool.query(menuQuery, [companyCode]);
  // 이름이 같은 잠재적 매칭 후보 조회
  const matchQuery = `
    SELECT 
      m.menu_name_kor as menu_name,
      sg.group_name
    FROM menu_info m
    JOIN screen_groups sg ON LOWER(TRIM(m.menu_name_kor)) = LOWER(TRIM(sg.group_name))
    WHERE m.company_code = $1 
      AND sg.company_code = $1
      AND m.menu_type = 1
      AND m.screen_group_id IS NULL
      AND sg.menu_objid IS NULL
    LIMIT 10
  `;
  const matchResult = await pool.query(matchQuery, [companyCode]);
  const sgTotal = parseInt(sgResult.rows[0].total);
  const sgLinked = parseInt(sgResult.rows[0].linked);
  const menuTotal = parseInt(menuResult.rows[0].total);
  const menuLinked = parseInt(menuResult.rows[0].linked);
  return {
    screenGroups: {
      total: sgTotal,
      linked: sgLinked,
      unlinked: sgTotal - sgLinked,
    },
    menuItems: {
      total: menuTotal,
      linked: menuLinked,
      unlinked: menuTotal - menuLinked,
    },
    potentialMatches: matchResult.rows.map((row: any) => ({
      menuName: row.menu_name,
      groupName: row.group_name,
      similarity: 'exact',
    })),
  };
 }
 // ============================================================
 // 전체 동기화 (모든 회사)
 // ============================================================
 interface AllCompaniesSyncResult {
  success: boolean;
  totalCompanies: number;
  successCount: number;
  failedCount: number;
  results: Array<{
    companyCode: string;
    companyName: string;
    direction: 'screens-to-menus' | 'menus-to-screens';
    created: number;
    linked: number;
    skipped: number;
    success: boolean;
    error?: string;
  }>;
 }
 /**
 * 모든 회사에 대해 양방향 동기화 수행
 * 
 * 로직:
 * 1. 모든 회사 조회
 * 2. 각 회사별로 양방향 동기화 수행
 *    - 화면관리 → 메뉴 동기화
 *    - 메뉴 → 화면관리 동기화
 * 3. 결과 집계
 */
 export async function syncAllCompanies(
  userId: string
 ): Promise<AllCompaniesSyncResult> {
  const result: AllCompaniesSyncResult = {
    success: true,
    totalCompanies: 0,
    successCount: 0,
    failedCount: 0,
    results: [],
  };
  try {
    logger.info("전체 동기화 시작", { userId });
    // 모든 회사 조회 (최고 관리자 전용 회사 제외)
    const companiesQuery = `
      SELECT company_code, company_name 
      FROM company_mng 
      WHERE company_code != '*'
      ORDER BY company_name
    `;
    const companiesResult = await pool.query(companiesQuery);
    result.totalCompanies = companiesResult.rows.length;
    // 각 회사별로 양방향 동기화
    for (const company of companiesResult.rows) {
      const companyCode = company.company_code;
      const companyName = company.company_name;
      try {
        // 1. 화면관리 → 메뉴 동기화
        const screensToMenusResult = await syncScreenGroupsToMenu(companyCode, userId);
        result.results.push({
          companyCode,
          companyName,
          direction: 'screens-to-menus',
          created: screensToMenusResult.created,
          linked: screensToMenusResult.linked,
          skipped: screensToMenusResult.skipped,
          success: screensToMenusResult.success,
          error: screensToMenusResult.errors.length > 0 ? screensToMenusResult.errors.join(', ') : undefined,
        });
        // 2. 메뉴 → 화면관리 동기화
        const menusToScreensResult = await syncMenuToScreenGroups(companyCode, userId);
        result.results.push({
          companyCode,
          companyName,
          direction: 'menus-to-screens',
          created: menusToScreensResult.created,
          linked: menusToScreensResult.linked,
          skipped: menusToScreensResult.skipped,
          success: menusToScreensResult.success,
          error: menusToScreensResult.errors.length > 0 ? menusToScreensResult.errors.join(', ') : undefined,
        });
        if (screensToMenusResult.success && menusToScreensResult.success) {
          result.successCount++;
        } else {
          result.failedCount++;
        }
      } catch (error: any) {
        logger.error("회사 동기화 실패", { companyCode, companyName, error: error.message });
        result.results.push({
          companyCode,
          companyName,
          direction: 'screens-to-menus',
          created: 0,
          linked: 0,
          skipped: 0,
          success: false,
          error: error.message,
        });
        result.failedCount++;
      }
    }
    logger.info("전체 동기화 완료", { 
      totalCompanies: result.totalCompanies,
      successCount: result.successCount,
      failedCount: result.failedCount,
    });
    return result;
  } catch (error: any) {
    logger.error("전체 동기화 실패", { error: error.message });
    result.success = false;
    return result;
  }
 }
--- a/backend-node/src/services/multilangService.ts
+++ b/backend-node/src/services/multilangService.ts
--- a/backend-node/src/services/nodeFlowExecutionService.ts
+++ b/backend-node/src/services/nodeFlowExecutionService.ts
@ -969,56 +969,21 @@ export class NodeFlowExecutionService {
        const insertedData = { ...data };
        console.log("🗺️ 필드 매핑 처리 중...");
-        
+        fieldMappings.forEach((mapping: any) => {
        // 🔥 채번 규칙 서비스 동적 import
        const { numberingRuleService } = await import("./numberingRuleService");
        for (const mapping of fieldMappings) {
          fields.push(mapping.targetField);
-          let value: any;
+          const value =
            mapping.staticValue !== undefined
              ? mapping.staticValue
              : data[mapping.sourceField];
          // 🔥 값 생성 유형에 따른 처리
          const valueType = mapping.valueType || (mapping.staticValue !== undefined ? "static" : "source");
          if (valueType === "autoGenerate" && mapping.numberingRuleId) {
            // 자동 생성 (채번 규칙)
            const companyCode = context.buttonContext?.companyCode || "*";
            try {
              value = await numberingRuleService.allocateCode(
                mapping.numberingRuleId,
                companyCode
              );
              console.log(
                `  🔢 자동 생성(채번): ${mapping.targetField} = ${value} (규칙: ${mapping.numberingRuleId})`
              );
            } catch (error: any) {
              logger.error(`채번 규칙 적용 실패: ${error.message}`);
              console.error(
                `  ❌ 채번 실패 → ${mapping.targetField}: ${error.message}`
              );
              throw new Error(
                `채번 규칙 '${mapping.numberingRuleName || mapping.numberingRuleId}' 적용 실패: ${error.message}`
              );
            }
          } else if (valueType === "static" || mapping.staticValue !== undefined) {
            // 고정값
            value = mapping.staticValue;
            console.log(
              `  📌 고정값: ${mapping.targetField} = ${value}`
            );
          } else {
            // 소스 필드
            value = data[mapping.sourceField];
          console.log(
            `  ${mapping.sourceField} → ${mapping.targetField}: ${value === undefined ? "❌ undefined" : "✅ " + value}`
          );
          }
          values.push(value);
          // 🔥 삽입된 값을 데이터에 반영
          insertedData[mapping.targetField] = value;
-        }
+        });
        // 🆕 writer와 company_code 자동 추가 (필드 매핑에 없는 경우)
        const hasWriterMapping = fieldMappings.some(
@ -1563,24 +1528,16 @@ export class NodeFlowExecutionService {
          }
        });
-        // 🔑 Primary Key 자동 추가 여부 결정:
+        // 🔑 Primary Key 자동 추가 (context-data 모드)
        // whereConditions가 명시적으로 설정되어 있으면 PK 자동 추가를 하지 않음
        // (사용자가 직접 조건을 설정한 경우 의도를 존중)
        let finalWhereConditions: any[];
        if (whereConditions && whereConditions.length > 0) {
          console.log("📋 사용자 정의 WHERE 조건 사용 (PK 자동 추가 안 함)");
          finalWhereConditions = whereConditions;
        } else {
        console.log("🔑 context-data 모드: Primary Key 자동 추가");
-          finalWhereConditions = await this.enhanceWhereConditionsWithPK(
+        const enhancedWhereConditions = await this.enhanceWhereConditionsWithPK(
          whereConditions,
          data,
          targetTable
        );
        }
        const whereResult = this.buildWhereClause(
-          finalWhereConditions,
+          enhancedWhereConditions,
          data,
          paramIndex
        );
@ -1950,30 +1907,22 @@ export class NodeFlowExecutionService {
        return deletedDataArray;
      }
-      // 🆕 context-data 모드: 개별 삭제
+      // 🆕 context-data 모드: 개별 삭제 (PK 자동 추가)
      console.log("🎯 context-data 모드: 개별 삭제 시작");
      for (const data of dataArray) {
        console.log("🔍 WHERE 조건 처리 중...");
-        // 🔑 Primary Key 자동 추가 여부 결정:
+        // 🔑 Primary Key 자동 추가 (context-data 모드)
        // whereConditions가 명시적으로 설정되어 있으면 PK 자동 추가를 하지 않음
        // (사용자가 직접 조건을 설정한 경우 의도를 존중)
        let finalWhereConditions: any[];
        if (whereConditions && whereConditions.length > 0) {
          console.log("📋 사용자 정의 WHERE 조건 사용 (PK 자동 추가 안 함)");
          finalWhereConditions = whereConditions;
        } else {
        console.log("🔑 context-data 모드: Primary Key 자동 추가");
-          finalWhereConditions = await this.enhanceWhereConditionsWithPK(
+        const enhancedWhereConditions = await this.enhanceWhereConditionsWithPK(
          whereConditions,
          data,
          targetTable
        );
        }
        const whereResult = this.buildWhereClause(
-          finalWhereConditions,
+          enhancedWhereConditions,
          data,
          1
        );
@ -2333,7 +2282,6 @@ export class NodeFlowExecutionService {
            UPDATE ${targetTable}
            SET ${setClauses.join(", ")}
            WHERE ${updateWhereConditions}
            RETURNING *
          `;
          logger.info(`🔄 UPDATE 실행:`, {
@ -2344,14 +2292,8 @@ export class NodeFlowExecutionService {
            values: updateValues,
          });
-          const updateResult = await txClient.query(updateSql, updateValues);
+          await txClient.query(updateSql, updateValues);
          updatedCount++;
          // 🆕 UPDATE 결과를 입력 데이터에 병합 (다음 노드에서 id 등 사용 가능)
          if (updateResult.rows && updateResult.rows[0]) {
            Object.assign(data, updateResult.rows[0]);
            logger.info(`  📦 UPDATE 결과 병합: id=${updateResult.rows[0].id}`);
          }
        } else {
          // 3-B. 없으면 INSERT
          const columns: string[] = [];
@ -2398,7 +2340,6 @@ export class NodeFlowExecutionService {
          const insertSql = `
            INSERT INTO ${targetTable} (${columns.join(", ")})
            VALUES (${placeholders})
            RETURNING *
          `;
          logger.info(`➕ INSERT 실행:`, {
@ -2407,14 +2348,8 @@ export class NodeFlowExecutionService {
            conflictKeyValues,
          });
-          const insertResult = await txClient.query(insertSql, values);
+          await txClient.query(insertSql, values);
          insertedCount++;
          // 🆕 INSERT 결과를 입력 데이터에 병합 (다음 노드에서 id 등 사용 가능)
          if (insertResult.rows && insertResult.rows[0]) {
            Object.assign(data, insertResult.rows[0]);
            logger.info(`  📦 INSERT 결과 병합: id=${insertResult.rows[0].id}`);
          }
        }
      }
@ -2422,10 +2357,11 @@ export class NodeFlowExecutionService {
        `✅ UPSERT 완료 (내부 DB): ${targetTable}, INSERT ${insertedCount}건, UPDATE ${updatedCount}건`
      );
-      // 🔥 다음 노드에 전달할 데이터 반환
+      return {
-      // dataArray에는 Object.assign으로 UPSERT 결과(id 등)가 이미 병합되어 있음
+        insertedCount,
-      // 카운트 정보도 함께 반환하여 기존 호환성 유지
+        updatedCount,
-      return dataArray;
+        totalCount: insertedCount + updatedCount,
      };
    };
    // 🔥 클라이언트가 전달되었으면 사용, 아니면 독립 트랜잭션 생성
@ -2771,31 +2707,10 @@ export class NodeFlowExecutionService {
      const trueData: any[] = [];
      const falseData: any[] = [];
-      // 배열의 각 항목에 대해 조건 평가 (EXISTS 조건은 비동기)
+      inputData.forEach((item: any) => {
-      for (const item of inputData) {
+        const results = conditions.map((condition: any) => {
        const results: boolean[] = [];
        for (const condition of conditions) {
          const fieldValue = item[condition.field];
          // EXISTS 계열 연산자 처리
          if (
            condition.operator === "EXISTS_IN" ||
            condition.operator === "NOT_EXISTS_IN"
          ) {
            const existsResult = await this.evaluateExistsCondition(
              fieldValue,
              condition.operator,
              condition.lookupTable,
              condition.lookupField,
              context.buttonContext?.companyCode
            );
            results.push(existsResult);
            logger.info(
              `🔍 EXISTS 조건: ${condition.field} (${fieldValue}) ${condition.operator} ${condition.lookupTable}.${condition.lookupField} => ${existsResult}`
            );
          } else {
            // 일반 연산자 처리
          let compareValue = condition.value;
          if (condition.valueType === "field") {
            compareValue = item[condition.value];
@ -2808,11 +2723,12 @@ export class NodeFlowExecutionService {
            );
          }
-            results.push(
+          return this.evaluateCondition(
-              this.evaluateCondition(fieldValue, condition.operator, compareValue)
+            fieldValue,
            condition.operator,
            compareValue
          );
-          }
+        });
        }
        const result =
          logic === "OR"
@ -2824,7 +2740,7 @@ export class NodeFlowExecutionService {
        } else {
          falseData.push(item);
        }
-      }
+      });
      logger.info(
        `🔍 조건 필터링 결과: TRUE ${trueData.length}건 / FALSE ${falseData.length}건 (${logic} 로직)`
@ -2839,29 +2755,9 @@ export class NodeFlowExecutionService {
    }
    // 단일 객체인 경우
-    const results: boolean[] = [];
+    const results = conditions.map((condition: any) => {
    for (const condition of conditions) {
      const fieldValue = inputData[condition.field];
      // EXISTS 계열 연산자 처리
      if (
        condition.operator === "EXISTS_IN" ||
        condition.operator === "NOT_EXISTS_IN"
      ) {
        const existsResult = await this.evaluateExistsCondition(
          fieldValue,
          condition.operator,
          condition.lookupTable,
          condition.lookupField,
          context.buttonContext?.companyCode
        );
        results.push(existsResult);
        logger.info(
          `🔍 EXISTS 조건: ${condition.field} (${fieldValue}) ${condition.operator} ${condition.lookupTable}.${condition.lookupField} => ${existsResult}`
        );
      } else {
        // 일반 연산자 처리
      let compareValue = condition.value;
      if (condition.valueType === "field") {
        compareValue = inputData[condition.value];
@ -2874,11 +2770,12 @@ export class NodeFlowExecutionService {
        );
      }
-        results.push(
+      return this.evaluateCondition(
-          this.evaluateCondition(fieldValue, condition.operator, compareValue)
+        fieldValue,
        condition.operator,
        compareValue
      );
-      }
+    });
    }
    const result =
      logic === "OR"
@ -2887,7 +2784,7 @@ export class NodeFlowExecutionService {
    logger.info(`🔍 조건 평가 결과: ${result} (${logic} 로직)`);
-    // 조건 노드는 TRUE/FALSE 브랜치를 위한 특별한 처리 필요
+    // ⚠️ 조건 노드는 TRUE/FALSE 브랜치를 위한 특별한 처리 필요
    // 조건 결과를 저장하고, 원본 데이터는 항상 반환
    // 다음 노드에서 sourceHandle을 기반으로 필터링됨
    return {
@ -2898,69 +2795,6 @@ export class NodeFlowExecutionService {
    };
  }
  /**
   * EXISTS_IN / NOT_EXISTS_IN 조건 평가
   * 다른 테이블에 값이 존재하는지 확인
   */
  private static async evaluateExistsCondition(
    fieldValue: any,
    operator: string,
    lookupTable: string,
    lookupField: string,
    companyCode?: string
  ): Promise<boolean> {
    if (!lookupTable || !lookupField) {
      logger.warn("⚠️ EXISTS 조건: lookupTable 또는 lookupField가 없습니다");
      return false;
    }
    if (fieldValue === null || fieldValue === undefined || fieldValue === "") {
      logger.info(
        `⚠️ EXISTS 조건: 필드값이 비어있어 FALSE 반환 (빈 값은 조건 검사하지 않음)`
      );
      // 값이 비어있으면 조건 검사 자체가 무의미하므로 항상 false 반환
      // 이렇게 하면 빈 값으로 인한 의도치 않은 INSERT/UPDATE/DELETE가 방지됨
      return false;
    }
    try {
      // 멀티테넌시: company_code 필터 적용 여부 확인
      // company_mng 테이블은 제외
      const hasCompanyCode = lookupTable !== "company_mng" && companyCode;
      let sql: string;
      let params: any[];
      if (hasCompanyCode) {
        sql = `SELECT EXISTS(SELECT 1 FROM "${lookupTable}" WHERE "${lookupField}" = $1 AND company_code = $2) as exists_result`;
        params = [fieldValue, companyCode];
      } else {
        sql = `SELECT EXISTS(SELECT 1 FROM "${lookupTable}" WHERE "${lookupField}" = $1) as exists_result`;
        params = [fieldValue];
      }
      logger.info(`🔍 EXISTS 쿼리: ${sql}, params: ${JSON.stringify(params)}`);
      const result = await query(sql, params);
      const existsInTable = result[0]?.exists_result === true;
      logger.info(
        `🔍 EXISTS 결과: ${fieldValue}이(가) ${lookupTable}.${lookupField}에 ${existsInTable ? "존재함" : "존재하지 않음"}`
      );
      // EXISTS_IN: 존재하면 true
      // NOT_EXISTS_IN: 존재하지 않으면 true
      if (operator === "EXISTS_IN") {
        return existsInTable;
      } else {
        return !existsInTable;
      }
    } catch (error: any) {
      logger.error(`❌ EXISTS 조건 평가 실패: ${error.message}`);
      return false;
    }
  }
  /**
   * WHERE 절 생성
   */
@ -4446,8 +4280,6 @@ export class NodeFlowExecutionService {
  /**
   * 산술 연산 계산
   * 다중 연산 지원: (leftOperand operator rightOperand) 이후 additionalOperations 순차 적용
   * 예: (width * height) / 1000000 * qty
   */
  private static evaluateArithmetic(
    arithmetic: any,
@ -4474,67 +4306,27 @@ export class NodeFlowExecutionService {
    const leftNum = Number(left) || 0;
    const rightNum = Number(right) || 0;
-    // 기본 연산 수행
+    switch (arithmetic.operator) {
    let result = this.applyOperator(leftNum, arithmetic.operator, rightNum);
    if (result === null) {
      return null;
    }
    // 추가 연산 처리 (다중 연산 지원)
    if (arithmetic.additionalOperations && Array.isArray(arithmetic.additionalOperations)) {
      for (const addOp of arithmetic.additionalOperations) {
        const operandValue = this.getOperandValue(
          addOp.operand,
          sourceRow,
          targetRow,
          resultValues
        );
        const operandNum = Number(operandValue) || 0;
        result = this.applyOperator(result, addOp.operator, operandNum);
        if (result === null) {
          logger.warn(`⚠️ 추가 연산 실패: ${addOp.operator}`);
          return null;
        }
        logger.info(`   추가 연산: ${addOp.operator} ${operandNum} = ${result}`);
      }
    }
    return result;
  }
  /**
   * 단일 연산자 적용
   */
  private static applyOperator(
    left: number,
    operator: string,
    right: number
  ): number | null {
    switch (operator) {
      case "+":
-        return left + right;
+        return leftNum + rightNum;
      case "-":
-        return left - right;
+        return leftNum - rightNum;
      case "*":
-        return left * right;
+        return leftNum * rightNum;
      case "/":
-        if (right === 0) {
+        if (rightNum === 0) {
          logger.warn(`⚠️ 0으로 나누기 시도`);
          return null;
        }
-        return left / right;
+        return leftNum / rightNum;
      case "%":
-        if (right === 0) {
+        if (rightNum === 0) {
          logger.warn(`⚠️ 0으로 나머지 연산 시도`);
          return null;
        }
-        return left % right;
+        return leftNum % rightNum;
      default:
-        throw new Error(`지원하지 않는 연산자: ${operator}`);
+        throw new Error(`지원하지 않는 연산자: ${arithmetic.operator}`);
    }
  }
--- a/backend-node/src/services/screenManagementService.ts
+++ b/backend-node/src/services/screenManagementService.ts
@ -2597,10 +2597,10 @@ export class ScreenManagementService {
      // 없으면 원본과 같은 회사에 복사
      const targetCompanyCode = copyData.targetCompanyCode || sourceScreen.company_code;
-      // 3. 화면 코드 중복 체크 (대상 회사 기준, 삭제되지 않은 화면만)
+      // 3. 화면 코드 중복 체크 (대상 회사 기준)
      const existingScreens = await client.query<any>(
        `SELECT screen_id FROM screen_definitions
-         WHERE screen_code = $1 AND company_code = $2 AND deleted_date IS NULL
+         WHERE screen_code = $1 AND company_code = $2
         LIMIT 1`,
        [copyData.screenCode, targetCompanyCode]
      );
--- a/backend-node/src/services/tableCategoryValueService.ts
+++ b/backend-node/src/services/tableCategoryValueService.ts
@ -187,11 +187,14 @@ class TableCategoryValueService {
        logger.info("형제 메뉴 OBJID 목록", { menuObjid, siblingObjids });
      }
-      // 2. 카테고리 값 조회 (메뉴 스코프 또는 형제 메뉴 포함)
+      // 2. 카테고리 값 조회 (형제 메뉴 포함)
      let query: string;
      let params: any[];
-      const baseSelect = `
+      if (companyCode === "*") {
        // 최고 관리자: 모든 카테고리 값 조회
        // 메뉴 스코프 제거: 같은 테이블.컬럼 조합은 모든 메뉴에서 공유
        query = `
          SELECT 
            value_id AS "valueId",
            table_name AS "tableName",
@ -216,39 +219,39 @@ class TableCategoryValueService {
          WHERE table_name = $1
            AND column_name = $2
        `;
      if (companyCode === "*") {
        // 최고 관리자: menuObjid가 있으면 해당 메뉴(및 형제 메뉴)의 값만 조회
        if (menuObjid && siblingObjids.length > 0) {
          query = baseSelect + ` AND menu_objid = ANY($3::numeric[])`;
          params = [tableName, columnName, siblingObjids];
          logger.info("최고 관리자 메뉴 스코프 카테고리 값 조회", { menuObjid, siblingObjids });
        } else if (menuObjid) {
          query = baseSelect + ` AND menu_objid = $3`;
          params = [tableName, columnName, menuObjid];
          logger.info("최고 관리자 단일 메뉴 카테고리 값 조회", { menuObjid });
        } else {
          // menuObjid 없으면 모든 값 조회 (중복 가능)
          query = baseSelect;
        params = [tableName, columnName];
-          logger.info("최고 관리자 전체 카테고리 값 조회 (menuObjid 없음)");
+        logger.info("최고 관리자 카테고리 값 조회");
        }
      } else {
-        // 일반 회사: 자신의 회사 + menuObjid로 필터링
+        // 일반 회사: 자신의 카테고리 값만 조회
-        if (menuObjid && siblingObjids.length > 0) {
+        // 메뉴 스코프 제거: 같은 테이블.컬럼 조합은 모든 메뉴에서 공유
-          query = baseSelect + ` AND company_code = $3 AND menu_objid = ANY($4::numeric[])`;
+        query = `
-          params = [tableName, columnName, companyCode, siblingObjids];
+          SELECT 
-          logger.info("회사별 메뉴 스코프 카테고리 값 조회", { companyCode, menuObjid, siblingObjids });
+            value_id AS "valueId",
-        } else if (menuObjid) {
+            table_name AS "tableName",
-          query = baseSelect + ` AND company_code = $3 AND menu_objid = $4`;
+            column_name AS "columnName",
-          params = [tableName, columnName, companyCode, menuObjid];
+            value_code AS "valueCode",
-          logger.info("회사별 단일 메뉴 카테고리 값 조회", { companyCode, menuObjid });
+            value_label AS "valueLabel",
-        } else {
+            value_order AS "valueOrder",
-          // menuObjid 없으면 회사 전체 조회 (중복 가능하지만 회사별로 제한)
+            parent_value_id AS "parentValueId",
-          query = baseSelect + ` AND company_code = $3`;
+            depth,
            description,
            color,
            icon,
            is_active AS "isActive",
            is_default AS "isDefault",
            company_code AS "companyCode",
            menu_objid AS "menuObjid",
            created_at AS "createdAt",
            updated_at AS "updatedAt",
            created_by AS "createdBy",
            updated_by AS "updatedBy"
          FROM table_column_category_values
          WHERE table_name = $1
            AND column_name = $2
            AND company_code = $3
        `;
        params = [tableName, columnName, companyCode];
-          logger.info("회사별 카테고리 값 조회 (menuObjid 없음)", { companyCode });
+        logger.info("회사별 카테고리 값 조회", { companyCode });
        }
      }
      if (!includeInactive) {
@ -1395,220 +1398,6 @@ class TableCategoryValueService {
      throw error;
    }
  }
  /**
   * 테이블의 카테고리 타입 컬럼과 해당 값 매핑 조회 (라벨 → 코드 변환용)
   * 
   * 엑셀 업로드 등에서 라벨 값을 코드 값으로 변환할 때 사용
   * 
   * @param tableName - 테이블명
   * @param companyCode - 회사 코드
   * @returns { [columnName]: { [label]: code } } 형태의 매핑 객체
   */
  async getCategoryLabelToCodeMapping(
    tableName: string,
    companyCode: string
  ): Promise<Record<string, Record<string, string>>> {
    try {
      logger.info("카테고리 라벨→코드 매핑 조회", { tableName, companyCode });
      const pool = getPool();
      // 1. 해당 테이블의 카테고리 타입 컬럼 조회
      const categoryColumnsQuery = `
        SELECT column_name
        FROM table_type_columns
        WHERE table_name = $1
          AND input_type = 'category'
      `;
      const categoryColumnsResult = await pool.query(categoryColumnsQuery, [tableName]);
      if (categoryColumnsResult.rows.length === 0) {
        logger.info("카테고리 타입 컬럼 없음", { tableName });
        return {};
      }
      const categoryColumns = categoryColumnsResult.rows.map(row => row.column_name);
      logger.info(`카테고리 컬럼 ${categoryColumns.length}개 발견`, { categoryColumns });
      // 2. 각 카테고리 컬럼의 라벨→코드 매핑 조회
      const result: Record<string, Record<string, string>> = {};
      for (const columnName of categoryColumns) {
        let query: string;
        let params: any[];
        if (companyCode === "*") {
          // 최고 관리자: 모든 카테고리 값 조회
          query = `
            SELECT value_code, value_label
            FROM table_column_category_values
            WHERE table_name = $1
              AND column_name = $2
              AND is_active = true
          `;
          params = [tableName, columnName];
        } else {
          // 일반 회사: 자신의 카테고리 값 + 공통 카테고리 값 조회
          query = `
            SELECT value_code, value_label
            FROM table_column_category_values
            WHERE table_name = $1
              AND column_name = $2
              AND is_active = true
              AND (company_code = $3 OR company_code = '*')
          `;
          params = [tableName, columnName, companyCode];
        }
        const valuesResult = await pool.query(query, params);
        // { [label]: code } 형태로 변환
        const labelToCodeMap: Record<string, string> = {};
        for (const row of valuesResult.rows) {
          // 라벨을 소문자로 변환하여 대소문자 구분 없이 매핑
          labelToCodeMap[row.value_label] = row.value_code;
          // 소문자 키도 추가 (대소문자 무시 검색용)
          labelToCodeMap[row.value_label.toLowerCase()] = row.value_code;
        }
        if (Object.keys(labelToCodeMap).length > 0) {
          result[columnName] = labelToCodeMap;
          logger.info(`컬럼 ${columnName}의 라벨→코드 매핑 ${valuesResult.rows.length}개 조회`);
        }
      }
      logger.info(`카테고리 라벨→코드 매핑 조회 완료`, { 
        tableName, 
        columnCount: Object.keys(result).length 
      });
      return result;
    } catch (error: any) {
      logger.error(`카테고리 라벨→코드 매핑 조회 실패: ${error.message}`, { error });
      throw error;
    }
  }
  /**
   * 데이터의 카테고리 라벨 값을 코드 값으로 변환
   * 
   * 엑셀 업로드 등에서 사용자가 입력한 라벨 값을 DB 저장용 코드 값으로 변환
   * 
   * @param tableName - 테이블명
   * @param companyCode - 회사 코드
   * @param data - 변환할 데이터 객체
   * @returns 라벨이 코드로 변환된 데이터 객체
   */
  async convertCategoryLabelsToCodesForData(
    tableName: string,
    companyCode: string,
    data: Record<string, any>
  ): Promise<{ convertedData: Record<string, any>; conversions: Array<{ column: string; label: string; code: string }> }> {
    try {
      // 라벨→코드 매핑 조회
      const labelToCodeMapping = await this.getCategoryLabelToCodeMapping(tableName, companyCode);
      if (Object.keys(labelToCodeMapping).length === 0) {
        // 카테고리 컬럼 없음
        return { convertedData: data, conversions: [] };
      }
      const convertedData = { ...data };
      const conversions: Array<{ column: string; label: string; code: string }> = [];
      for (const [columnName, labelCodeMap] of Object.entries(labelToCodeMapping)) {
        const value = data[columnName];
        if (value !== undefined && value !== null && value !== "") {
          const stringValue = String(value).trim();
          // 다중 값 확인 (쉼표로 구분된 경우)
          if (stringValue.includes(",")) {
            // 다중 카테고리 값 처리
            const labels = stringValue.split(",").map(s => s.trim()).filter(s => s !== "");
            const convertedCodes: string[] = [];
            let allConverted = true;
            for (const label of labels) {
              // 정확한 라벨 매칭 시도
              let matchedCode = labelCodeMap[label];
              // 대소문자 무시 매칭
              if (!matchedCode) {
                matchedCode = labelCodeMap[label.toLowerCase()];
              }
              if (matchedCode) {
                convertedCodes.push(matchedCode);
                conversions.push({
                  column: columnName,
                  label: label,
                  code: matchedCode,
                });
                logger.info(`카테고리 라벨→코드 변환 (다중): ${columnName} "${label}" → "${matchedCode}"`);
              } else {
                // 이미 코드값인지 확인
                const isAlreadyCode = Object.values(labelCodeMap).includes(label);
                if (isAlreadyCode) {
                  // 이미 코드값이면 그대로 사용
                  convertedCodes.push(label);
                } else {
                  // 라벨도 코드도 아니면 원래 값 유지
                  convertedCodes.push(label);
                  allConverted = false;
                  logger.warn(`카테고리 값 매핑 없음 (다중): ${columnName} = "${label}" (라벨도 코드도 아님)`);
                }
              }
            }
            // 변환된 코드들을 쉼표로 합쳐서 저장
            convertedData[columnName] = convertedCodes.join(",");
            logger.info(`다중 카테고리 변환 완료: ${columnName} "${stringValue}" → "${convertedData[columnName]}"`);
          } else {
            // 단일 값 처리
            // 정확한 라벨 매칭 시도
            let matchedCode = labelCodeMap[stringValue];
            // 대소문자 무시 매칭
            if (!matchedCode) {
              matchedCode = labelCodeMap[stringValue.toLowerCase()];
            }
            if (matchedCode) {
              // 라벨 값을 코드 값으로 변환
              convertedData[columnName] = matchedCode;
              conversions.push({
                column: columnName,
                label: stringValue,
                code: matchedCode,
              });
              logger.info(`카테고리 라벨→코드 변환: ${columnName} "${stringValue}" → "${matchedCode}"`);
            } else {
              // 이미 코드값인지 확인 (역방향 확인)
              const isAlreadyCode = Object.values(labelCodeMap).includes(stringValue);
              if (!isAlreadyCode) {
                logger.warn(`카테고리 값 매핑 없음: ${columnName} = "${stringValue}" (라벨도 코드도 아님)`);
              }
              // 변환 없이 원래 값 유지
            }
          }
        }
      }
      logger.info(`카테고리 라벨→코드 변환 완료`, {
        tableName,
        conversionCount: conversions.length,
        conversions,
      });
      return { convertedData, conversions };
    } catch (error: any) {
      logger.error(`카테고리 라벨→코드 변환 실패: ${error.message}`, { error });
      // 실패 시 원본 데이터 반환
      return { convertedData: data, conversions: [] };
    }
  }
 }
 export default new TableCategoryValueService();
--- a/backend-node/src/services/tableManagementService.ts
+++ b/backend-node/src/services/tableManagementService.ts
@ -1306,48 +1306,6 @@ export class TableManagementService {
    paramCount: number;
  } | null> {
    try {
      // 🆕 배열 값 처리 (다중 값 검색 - 분할패널 엔티티 타입에서 "2,3" 형태 지원)
      // 좌측에서 "2"를 선택해도, 우측에서 "2,3"을 가진 행이 표시되도록 함
      if (Array.isArray(value) && value.length > 0) {
        // 배열의 각 값에 대해 OR 조건으로 검색
        // 우측 컬럼에 "2,3" 같은 다중 값이 있을 수 있으므로
        // 각 값을 LIKE 또는 = 조건으로 처리
        const conditions: string[] = [];
        const values: any[] = [];
        value.forEach((v: any, idx: number) => {
          const safeValue = String(v).trim();
          // 정확히 일치하거나, 콤마로 구분된 값 중 하나로 포함
          // 예: "2,3" 컬럼에서 "2"를 찾으려면:
          // - 정확히 "2"
          // - "2," 로 시작
          // - ",2" 로 끝남
          // - ",2," 중간에 포함
          const paramBase = paramIndex + idx * 4;
          conditions.push(`(
            ${columnName}::text = $${paramBase} OR
            ${columnName}::text LIKE $${paramBase + 1} OR
            ${columnName}::text LIKE $${paramBase + 2} OR
            ${columnName}::text LIKE $${paramBase + 3}
          )`);
          values.push(
            safeValue,
            `${safeValue},%`,
            `%,${safeValue}`,
            `%,${safeValue},%`
          );
        });
        logger.info(
          `🔍 다중 값 배열 검색: ${columnName} IN [${value.join(", ")}]`
        );
        return {
          whereClause: `(${conditions.join(" OR ")})`,
          values,
          paramCount: values.length,
        };
      }
      // 🔧 파이프로 구분된 문자열 처리 (다중선택 또는 날짜 범위)
      if (typeof value === "string" && value.includes("|")) {
        const columnInfo = await this.getColumnWebTypeInfo(
@ -1782,26 +1740,18 @@ export class TableManagementService {
        // displayColumn이 비어있거나 "none"이면 참조 테이블에서 자동 감지 (entityJoinService와 동일한 로직)
        let displayColumn = entityTypeInfo.displayColumn;
-        if (
+        if (!displayColumn || displayColumn === "none" || displayColumn === "") {
-          !displayColumn ||
+          displayColumn = await this.findDisplayColumnForTable(referenceTable, referenceColumn);
          displayColumn === "none" ||
          displayColumn === ""
        ) {
          displayColumn = await this.findDisplayColumnForTable(
            referenceTable,
            referenceColumn
          );
          logger.info(
            `🔍 [buildEntitySearchCondition] displayColumn 자동 감지: ${referenceTable} -> ${displayColumn}`
          );
        }
        // 참조 테이블의 표시 컬럼으로 검색
        // 🔧 main. 접두사 추가: EXISTS 서브쿼리에서 외부 테이블 참조 시 명시적으로 지정
        return {
          whereClause: `EXISTS (
            SELECT 1 FROM ${referenceTable} ref 
-            WHERE ref.${referenceColumn} = main.${columnName} 
+            WHERE ref.${referenceColumn} = ${columnName} 
            AND ref.${displayColumn} ILIKE $${paramIndex}
          )`,
          values: [`%${value}%`],
@ -2165,14 +2115,14 @@ export class TableManagementService {
      // 안전한 테이블명 검증
      const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, "");
-      // 전체 개수 조회 (main 별칭 추가 - buildWhereClause가 main. 접두사를 사용하므로 필요)
+      // 전체 개수 조회
-      const countQuery = `SELECT COUNT(*) as count FROM ${safeTableName} main ${whereClause}`;
+      const countQuery = `SELECT COUNT(*) as count FROM ${safeTableName} ${whereClause}`;
      const countResult = await query<any>(countQuery, searchValues);
      const total = parseInt(countResult[0].count);
-      // 데이터 조회 (main 별칭 추가)
+      // 데이터 조회
      const dataQuery = `
-        SELECT main.* FROM ${safeTableName} main 
+        SELECT * FROM ${safeTableName} 
        ${whereClause} 
        ${orderClause}
        LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
@ -2311,12 +2261,11 @@ export class TableManagementService {
  /**
   * 테이블에 데이터 추가
   * @returns 무시된 컬럼 정보 (디버깅용)
   */
  async addTableData(
    tableName: string,
    data: Record<string, any>
-  ): Promise<{ skippedColumns: string[]; savedColumns: string[] }> {
+  ): Promise<void> {
    try {
      logger.info(`=== 테이블 데이터 추가 시작: ${tableName} ===`);
      logger.info(`추가할 데이터:`, data);
@ -2347,41 +2296,10 @@ export class TableManagementService {
        logger.info(`created_date 자동 추가: ${data.created_date}`);
      }
-      // 🆕 테이블에 존재하는 컬럼만 필터링 (존재하지 않는 컬럼은 무시)
+      // 컬럼명과 값을 분리하고 타입에 맞게 변환
-      const skippedColumns: string[] = [];
+      const columns = Object.keys(data);
-      const existingColumns = Object.keys(data).filter((col) => {
+      const values = Object.values(data).map((value, index) => {
-        const exists = columnTypeMap.has(col);
+        const columnName = columns[index];
        if (!exists) {
          skippedColumns.push(col);
        }
        return exists;
      });
      // 무시된 컬럼이 있으면 경고 로그 출력
      if (skippedColumns.length > 0) {
        logger.warn(
          `⚠️ [${tableName}] 테이블에 존재하지 않는 컬럼 ${skippedColumns.length}개 무시됨: ${skippedColumns.join(", ")}`
        );
        logger.warn(
          `⚠️ [${tableName}] 무시된 컬럼 상세:`,
          skippedColumns.map((col) => ({ column: col, value: data[col] }))
        );
      }
      if (existingColumns.length === 0) {
        throw new Error(
          `저장할 유효한 컬럼이 없습니다. 테이블: ${tableName}, 전달된 컬럼: ${Object.keys(data).join(", ")}`
        );
      }
      logger.info(
        `✅ [${tableName}] 저장될 컬럼 ${existingColumns.length}개: ${existingColumns.join(", ")}`
      );
      // 컬럼명과 값을 분리하고 타입에 맞게 변환 (존재하는 컬럼만)
      const columns = existingColumns;
      const values = columns.map((columnName) => {
        const value = data[columnName];
        const dataType = columnTypeMap.get(columnName) || "text";
        const convertedValue = this.convertValueForPostgreSQL(value, dataType);
        logger.info(
@ -2437,12 +2355,6 @@ export class TableManagementService {
      await query(insertQuery, values);
      logger.info(`테이블 데이터 추가 완료: ${tableName}`);
      // 무시된 컬럼과 저장된 컬럼 정보 반환
      return {
        skippedColumns,
        savedColumns: existingColumns,
      };
    } catch (error) {
      logger.error(`테이블 데이터 추가 오류: ${tableName}`, error);
      throw error;
@ -2497,19 +2409,11 @@ export class TableManagementService {
      }
      // SET 절 생성 (수정할 데이터) - 먼저 생성
      // 🔧 테이블에 존재하는 컬럼만 UPDATE (가상 컬럼 제외)
      const setConditions: string[] = [];
      const setValues: any[] = [];
      let paramIndex = 1;
      const skippedColumns: string[] = [];
      Object.keys(updatedData).forEach((column) => {
        // 테이블에 존재하지 않는 컬럼은 스킵
        if (!columnTypeMap.has(column)) {
          skippedColumns.push(column);
          return;
        }
        const dataType = columnTypeMap.get(column) || "text";
        setConditions.push(
          `"${column}" = $${paramIndex}::${this.getPostgreSQLType(dataType)}`
@ -2520,12 +2424,6 @@ export class TableManagementService {
        paramIndex++;
      });
      if (skippedColumns.length > 0) {
        logger.info(
          `⚠️ 테이블에 존재하지 않는 컬럼 스킵: ${skippedColumns.join(", ")}`
        );
      }
      // WHERE 조건 생성 (PRIMARY KEY 우선, 없으면 모든 원본 데이터 사용)
      let whereConditions: string[] = [];
      let whereValues: any[] = [];
@ -2728,12 +2626,6 @@ export class TableManagementService {
        filterColumn?: string;
        filterValue?: any;
      }; // 🆕 제외 필터 (다른 테이블에 이미 존재하는 데이터 제외)
      deduplication?: {
        enabled: boolean;
        groupByColumn: string;
        keepStrategy: "latest" | "earliest" | "base_price" | "current_date";
        sortColumn?: string;
      }; // 🆕 중복 제거 설정
    }
  ): Promise<EntityJoinResponse> {
    const startTime = Date.now();
@ -2784,74 +2676,33 @@ export class TableManagementService {
        );
        for (const additionalColumn of options.additionalJoinColumns) {
-          // 🔍 1차: sourceColumn을 기준으로 기존 조인 설정 찾기
+          // 🔍 sourceColumn을 기준으로 기존 조인 설정 찾기 (dept_code로 찾기)
-          let baseJoinConfig = joinConfigs.find(
+          const baseJoinConfig = joinConfigs.find(
            (config) => config.sourceColumn === additionalColumn.sourceColumn
          );
          // 🔍 2차: referenceTable을 기준으로 찾기 (프론트엔드가 customer_mng.customer_name 같은 형식을 요청할 때)
          // 실제 소스 컬럼이 partner_id인데 프론트엔드가 customer_id로 추론하는 경우 대응
          if (!baseJoinConfig && (additionalColumn as any).referenceTable) {
            baseJoinConfig = joinConfigs.find(
              (config) =>
                config.referenceTable ===
                (additionalColumn as any).referenceTable
            );
          if (baseJoinConfig) {
-              logger.info(
+            // joinAlias에서 실제 컬럼명 추출 (예: dept_code_location_name -> location_name)
-                `🔄 referenceTable로 조인 설정 찾음: ${(additionalColumn as any).referenceTable} → ${baseJoinConfig.sourceColumn}`
+            // sourceColumn을 제거한 나머지 부분이 실제 컬럼명
-              );
+            const sourceColumn = baseJoinConfig.sourceColumn; // dept_code
-            }
+            const joinAlias = additionalColumn.joinAlias; // dept_code_company_name
-          }
+            const actualColumnName = joinAlias.replace(`${sourceColumn}_`, ""); // company_name
          if (baseJoinConfig) {
            // joinAlias에서 실제 컬럼명 추출
            const sourceColumn = baseJoinConfig.sourceColumn; // 실제 소스 컬럼 (예: partner_id)
            const originalJoinAlias = additionalColumn.joinAlias; // 프론트엔드가 보낸 별칭 (예: customer_id_customer_name)
            // 🔄 프론트엔드가 잘못된 소스 컬럼으로 추론한 경우 처리
            // customer_id_customer_name → customer_name 추출 (customer_id_ 부분 제거)
            // 또는 partner_id_customer_name → customer_name 추출 (partner_id_ 부분 제거)
            let actualColumnName: string;
            // 프론트엔드가 보낸 joinAlias에서 실제 컬럼명 추출
            const frontendSourceColumn = additionalColumn.sourceColumn; // 프론트엔드가 추론한 소스 컬럼 (customer_id)
            if (originalJoinAlias.startsWith(`${frontendSourceColumn}_`)) {
              // 프론트엔드가 추론한 소스 컬럼으로 시작하면 그 부분 제거
              actualColumnName = originalJoinAlias.replace(
                `${frontendSourceColumn}_`,
                ""
              );
            } else if (originalJoinAlias.startsWith(`${sourceColumn}_`)) {
              // 실제 소스 컬럼으로 시작하면 그 부분 제거
              actualColumnName = originalJoinAlias.replace(
                `${sourceColumn}_`,
                ""
              );
            } else {
              // 어느 것도 아니면 원본 사용
              actualColumnName = originalJoinAlias;
            }
            // 🆕 올바른 joinAlias 재생성 (실제 소스 컬럼 기반)
            const correctedJoinAlias = `${sourceColumn}_${actualColumnName}`;
            logger.info(`🔍 조인 컬럼 상세 분석:`, {
              sourceColumn,
-              frontendSourceColumn,
+              joinAlias,
              originalJoinAlias,
              correctedJoinAlias,
              actualColumnName,
-              referenceTable: (additionalColumn as any).referenceTable,
+              referenceTable: additionalColumn.sourceTable,
            });
            // 🚨 기본 Entity 조인과 중복되지 않도록 체크
            const isBasicEntityJoin =
-              correctedJoinAlias === `${sourceColumn}_name`;
+              additionalColumn.joinAlias ===
              `${baseJoinConfig.sourceColumn}_name`;
            if (isBasicEntityJoin) {
              logger.info(
-                `⚠️ 기본 Entity 조인과 중복: ${correctedJoinAlias} - 건너뜀`
+                `⚠️ 기본 Entity 조인과 중복: ${additionalColumn.joinAlias} - 건너뜀`
              );
              continue; // 기본 Entity 조인과 중복되면 추가하지 않음
            }
@ -2859,14 +2710,14 @@ export class TableManagementService {
            // 추가 조인 컬럼 설정 생성
            const additionalJoinConfig: EntityJoinConfig = {
              sourceTable: tableName,
-              sourceColumn: sourceColumn, // 실제 소스 컬럼 (partner_id)
+              sourceColumn: baseJoinConfig.sourceColumn, // 원본 컬럼 (dept_code)
              referenceTable:
                (additionalColumn as any).referenceTable ||
-                baseJoinConfig.referenceTable, // 참조 테이블 (customer_mng)
+                baseJoinConfig.referenceTable, // 참조 테이블 (dept_info)
-              referenceColumn: baseJoinConfig.referenceColumn, // 참조 키 (customer_code)
+              referenceColumn: baseJoinConfig.referenceColumn, // 참조 키 (dept_code)
-              displayColumns: [actualColumnName], // 표시할 컬럼들 (customer_name)
+              displayColumns: [actualColumnName], // 표시할 컬럼들 (company_name)
              displayColumn: actualColumnName, // 하위 호환성
-              aliasColumn: correctedJoinAlias, // 수정된 별칭 (partner_id_customer_name)
+              aliasColumn: additionalColumn.joinAlias, // 별칭 (dept_code_company_name)
              separator: " - ", // 기본 구분자
            };
@ -3226,10 +3077,8 @@ export class TableManagementService {
      }
      // Entity 조인 컬럼 검색이 있는지 확인 (기본 조인 + 추가 조인 컬럼 모두 포함)
      // 🔧 sourceColumn도 포함: search={"order_no":"..."} 형태도 Entity 검색으로 인식
      const allEntityColumns = [
        ...joinConfigs.map((config) => config.aliasColumn),
        ...joinConfigs.map((config) => config.sourceColumn), // 🔧 소스 컬럼도 포함
        // 추가 조인 컬럼들도 포함 (writer_dept_code, company_code_status 등)
        ...joinConfigs.flatMap((config) => {
          const additionalColumns = [];
@ -3635,10 +3484,8 @@ export class TableManagementService {
          });
          // main. 접두사 추가 (조인 쿼리용)
          // 🔧 이미 접두사(. 앞)가 있는 경우는 교체하지 않음 (ref.column, main.column 등)
          // Negative lookbehind (?<!\.) 사용: 앞에 .이 없는 경우만 매칭
          condition = condition.replace(
-            new RegExp(`(?<!\\.)\\b${columnName}\\b`, "g"),
+            new RegExp(`\\b${columnName}\\b`, "g"),
            `main.${columnName}`
          );
          conditions.push(condition);
@ -3837,18 +3684,6 @@ export class TableManagementService {
    const cacheableJoins: EntityJoinConfig[] = [];
    const dbJoins: EntityJoinConfig[] = [];
    // 🔒 멀티테넌시: 회사별 데이터 테이블은 캐시 사용 불가 (company_code 필터링 필요)
    const companySpecificTables = [
      "supplier_mng",
      "customer_mng",
      "item_info",
      "dept_info",
      "sales_order_mng", // 🔧 수주관리 테이블 추가
      "sales_order_detail", // 🔧 수주상세 테이블 추가
      "partner_info", // 🔧 거래처 테이블 추가
      // 필요시 추가
    ];
    for (const config of joinConfigs) {
      // table_column_category_values는 특수 조인 조건이 필요하므로 항상 DB 조인
      if (config.referenceTable === "table_column_category_values") {
@ -3857,13 +3692,6 @@ export class TableManagementService {
        continue;
      }
      // 🔒 회사별 데이터 테이블은 캐시 사용 불가 (멀티테넌시)
      if (companySpecificTables.includes(config.referenceTable)) {
        dbJoins.push(config);
        console.log(`🔗 DB 조인 (멀티테넌시): ${config.referenceTable}`);
        continue;
      }
      // 캐시 가능성 확인
      const cachedData = await referenceCacheService.getCachedReference(
        config.referenceTable,
@ -4102,10 +3930,9 @@ export class TableManagementService {
        `컬럼 입력타입 정보 조회: ${tableName}, company: ${companyCode}`
      );
-      // table_type_columns에서 입력타입 정보 조회
+      // table_type_columns에서 입력타입 정보 조회 (company_code 필터링)
      // 회사별 설정 우선, 없으면 기본 설정(*) fallback
      const rawInputTypes = await query<any>(
-        `SELECT DISTINCT ON (ttc.column_name)
+        `SELECT 
          ttc.column_name as "columnName",
          COALESCE(cl.column_label, ttc.column_name) as "displayName",
          ttc.input_type as "inputType",
@ -4119,10 +3946,8 @@ export class TableManagementService {
        LEFT JOIN information_schema.columns ic 
          ON ttc.table_name = ic.table_name AND ttc.column_name = ic.column_name
        WHERE ttc.table_name = $1 
-          AND ttc.company_code IN ($2, '*')
+          AND ttc.company_code = $2
-        ORDER BY ttc.column_name, 
+        ORDER BY ttc.display_order, ttc.column_name`,
          CASE WHEN ttc.company_code = $2 THEN 0 ELSE 1 END,
          ttc.display_order`,
        [tableName, companyCode]
      );
@ -4136,20 +3961,17 @@ export class TableManagementService {
      const mappingTableExists = tableExistsResult[0]?.table_exists === true;
      // 카테고리 컬럼의 경우, 매핑된 메뉴 목록 조회
      // 회사별 설정 우선, 없으면 기본 설정(*) fallback
      let categoryMappings: Map<string, number[]> = new Map();
      if (mappingTableExists) {
        logger.info("카테고리 매핑 조회 시작", { tableName, companyCode });
        const mappings = await query<any>(
-          `SELECT DISTINCT ON (logical_column_name, menu_objid)
+          `SELECT 
            logical_column_name as "columnName",
            menu_objid as "menuObjid"
          FROM category_column_mapping
          WHERE table_name = $1 
-            AND company_code IN ($2, '*')
+            AND company_code = $2`,
          ORDER BY logical_column_name, menu_objid,
            CASE WHEN company_code = $2 THEN 0 ELSE 1 END`,
          [tableName, companyCode]
        );
@ -4752,110 +4574,4 @@ export class TableManagementService {
      return false;
    }
  }
  /**
   * 두 테이블 간의 엔티티 관계 자동 감지
   * column_labels에서 엔티티 타입 설정을 기반으로 테이블 간 관계를 찾습니다.
   *
   * @param leftTable 좌측 테이블명
   * @param rightTable 우측 테이블명
   * @returns 감지된 엔티티 관계 배열
   */
  async detectTableEntityRelations(
    leftTable: string,
    rightTable: string
  ): Promise<
    Array<{
      leftColumn: string;
      rightColumn: string;
      direction: "left_to_right" | "right_to_left";
      inputType: string;
      displayColumn?: string;
    }>
  > {
    try {
      logger.info(
        `두 테이블 간 엔티티 관계 감지 시작: ${leftTable} <-> ${rightTable}`
      );
      const relations: Array<{
        leftColumn: string;
        rightColumn: string;
        direction: "left_to_right" | "right_to_left";
        inputType: string;
        displayColumn?: string;
      }> = [];
      // 1. 우측 테이블에서 좌측 테이블을 참조하는 엔티티 컬럼 찾기
      // 예: right_table의 customer_id -> left_table(customer_mng)의 customer_code
      const rightToLeftRels = await query<{
        column_name: string;
        reference_column: string;
        input_type: string;
        display_column: string | null;
      }>(
        `SELECT column_name, reference_column, input_type, display_column
         FROM column_labels
         WHERE table_name = $1 
         AND input_type IN ('entity', 'category')
         AND reference_table = $2
         AND reference_column IS NOT NULL 
         AND reference_column != ''`,
        [rightTable, leftTable]
      );
      for (const rel of rightToLeftRels) {
        relations.push({
          leftColumn: rel.reference_column,
          rightColumn: rel.column_name,
          direction: "right_to_left",
          inputType: rel.input_type,
          displayColumn: rel.display_column || undefined,
        });
      }
      // 2. 좌측 테이블에서 우측 테이블을 참조하는 엔티티 컬럼 찾기
      // 예: left_table의 item_id -> right_table(item_info)의 item_number
      const leftToRightRels = await query<{
        column_name: string;
        reference_column: string;
        input_type: string;
        display_column: string | null;
      }>(
        `SELECT column_name, reference_column, input_type, display_column
         FROM column_labels
         WHERE table_name = $1 
         AND input_type IN ('entity', 'category')
         AND reference_table = $2
         AND reference_column IS NOT NULL 
         AND reference_column != ''`,
        [leftTable, rightTable]
      );
      for (const rel of leftToRightRels) {
        relations.push({
          leftColumn: rel.column_name,
          rightColumn: rel.reference_column,
          direction: "left_to_right",
          inputType: rel.input_type,
          displayColumn: rel.display_column || undefined,
        });
      }
      logger.info(`엔티티 관계 감지 완료: ${relations.length}개 발견`);
      relations.forEach((rel, idx) => {
        logger.info(
          `  ${idx + 1}. ${leftTable}.${rel.leftColumn} <-> ${rightTable}.${rel.rightColumn} (${rel.direction})`
        );
      });
      return relations;
    } catch (error) {
      logger.error(
        `엔티티 관계 감지 실패: ${leftTable} <-> ${rightTable}`,
        error
      );
      return [];
    }
  }
 }
--- a/backend-node/src/types/multilang.ts
+++ b/backend-node/src/types/multilang.ts
@ -17,30 +17,12 @@ export interface LangKey {
  langKey: string;
  description?: string;
  isActive: string;
  categoryId?: number;
  keyMeaning?: string;
  usageNote?: string;
  baseKeyId?: number;
  createdDate?: Date;
  createdBy?: string;
  updatedDate?: Date;
  updatedBy?: string;
 }
 // 카테고리 인터페이스
 export interface LangCategory {
  categoryId: number;
  categoryCode: string;
  categoryName: string;
  parentId?: number | null;
  level: number;
  keyPrefix: string;
  description?: string;
  sortOrder: number;
  isActive: string;
  children?: LangCategory[];
 }
 export interface LangText {
  textId?: number;
  keyId: number;
@ -81,38 +63,10 @@ export interface CreateLangKeyRequest {
  langKey: string;
  description?: string;
  isActive?: string;
  categoryId?: number;
  keyMeaning?: string;
  usageNote?: string;
  baseKeyId?: number;
  createdBy?: string;
  updatedBy?: string;
 }
 // 자동 키 생성 요청
 export interface GenerateKeyRequest {
  companyCode: string;
  categoryId: number;
  keyMeaning: string;
  usageNote?: string;
  texts: Array<{
    langCode: string;
    langText: string;
  }>;
  createdBy?: string;
 }
 // 오버라이드 키 생성 요청
 export interface CreateOverrideKeyRequest {
  companyCode: string;
  baseKeyId: number;
  texts: Array<{
    langCode: string;
    langText: string;
  }>;
  createdBy?: string;
 }
 export interface UpdateLangKeyRequest {
  companyCode?: string;
  menuName?: string;
@ -136,8 +90,6 @@ export interface GetLangKeysParams {
  menuCode?: string;
  keyType?: string;
  searchText?: string;
  categoryId?: number;
  includeOverrides?: boolean;
  page?: number;
  limit?: number;
 }
--- a/docs/노드플로우_개선사항.md
+++ b/docs/노드플로우_개선사항.md
@ -587,5 +587,3 @@ const result = await executeNodeFlow(flowId, {
--- a/docs/다국어_관리_시스템_개선_계획서.md
+++ b/docs/다국어_관리_시스템_개선_계획서.md
@ -1,597 +0,0 @@
 # 다국어 관리 시스템 개선 계획서
 ## 1. 개요
 ### 1.1 현재 시스템 분석
 현재 ERP 시스템의 다국어 관리 시스템은 기본적인 기능은 갖추고 있으나 다음과 같은 한계점이 있습니다.
 | 항목 | 현재 상태 | 문제점 |
 |------|----------|--------|
 | 회사별 다국어 | `company_code` 컬럼 존재하나 `*`(공통)만 사용 | 회사별 커스텀 번역 불가 |
 | 언어 키 입력 | 수동 입력 (`button.add` 등) | 명명 규칙 불일치, 오타, 중복 위험 |
 | 카테고리 분류 | 없음 (`menu_name` 텍스트만 존재) | 체계적 분류/검색 불가 |
 | 권한 관리 | 없음 | 모든 사용자가 모든 키 수정 가능 |
 | 조회 우선순위 | 없음 | 회사별 오버라이드 불가 |
 ### 1.2 개선 목표
 1. **회사별 다국어 오버라이드 시스템**: 공통 키를 기본으로 사용하되, 회사별 커스텀 번역 지원
 2. **권한 기반 접근 제어**: 공통 키는 최고 관리자만, 회사 키는 해당 회사만 수정
 3. **카테고리 기반 분류**: 2단계 계층 구조로 체계적 분류
 4. **자동 키 생성**: 카테고리 선택 + 의미 입력으로 규칙화된 키 자동 생성
 5. **실시간 중복 체크**: 키 생성 시 중복 여부 즉시 확인
 ---
 ## 2. 데이터베이스 스키마 설계
 ### 2.1 신규 테이블: multi_lang_category (카테고리 마스터)
 ```sql
 CREATE TABLE multi_lang_category (
  category_id SERIAL PRIMARY KEY,
  category_code VARCHAR(50) NOT NULL,           -- BUTTON, FORM, MESSAGE 등
  category_name VARCHAR(100) NOT NULL,          -- 버튼, 폼, 메시지 등
  parent_id INT4 REFERENCES multi_lang_category(category_id),
  level INT4 DEFAULT 1,                         -- 1=대분류, 2=세부분류
  key_prefix VARCHAR(50) NOT NULL,              -- 키 생성용 prefix
  description TEXT,
  sort_order INT4 DEFAULT 0,
  is_active CHAR(1) DEFAULT 'Y',
  created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  created_by VARCHAR(50),
  updated_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_by VARCHAR(50),
  UNIQUE(category_code, COALESCE(parent_id, 0))
 );
 -- 인덱스
 CREATE INDEX idx_lang_category_parent ON multi_lang_category(parent_id);
 CREATE INDEX idx_lang_category_level ON multi_lang_category(level);
 ```
 ### 2.2 기존 테이블 수정: multi_lang_key_master
 ```sql
 -- 카테고리 연결 컬럼 추가
 ALTER TABLE multi_lang_key_master 
 ADD COLUMN category_id INT4 REFERENCES multi_lang_category(category_id);
 -- 키 의미 컬럼 추가 (자동 생성 시 사용자 입력값)
 ALTER TABLE multi_lang_key_master 
 ADD COLUMN key_meaning VARCHAR(100);
 -- 원본 키 참조 (오버라이드 시 원본 추적)
 ALTER TABLE multi_lang_key_master 
 ADD COLUMN base_key_id INT4 REFERENCES multi_lang_key_master(key_id);
 -- menu_name을 usage_note로 변경 (사용 위치 메모)
 ALTER TABLE multi_lang_key_master 
 RENAME COLUMN menu_name TO usage_note;
 -- 인덱스 추가
 CREATE INDEX idx_lang_key_category ON multi_lang_key_master(category_id);
 CREATE INDEX idx_lang_key_company_category ON multi_lang_key_master(company_code, category_id);
 CREATE INDEX idx_lang_key_base ON multi_lang_key_master(base_key_id);
 ```
 ### 2.3 테이블 관계도
 ```
 multi_lang_category (1) ◀────────┐
  ├── category_id (PK)            │
  ├── category_code               │
  ├── parent_id (자기참조)         │
  └── key_prefix                  │
                                  │
 multi_lang_key_master (N) ────────┘
  ├── key_id (PK)
  ├── company_code ('*' = 공통)
  ├── category_id (FK)
  ├── lang_key (자동 생성)
  ├── key_meaning (사용자 입력)
  ├── base_key_id (오버라이드 시 원본)
  └── usage_note (사용 위치 메모)
              │
              ▼
 multi_lang_text (N)
  ├── text_id (PK)
  ├── key_id (FK)
  ├── lang_code (FK → language_master)
  └── lang_text
 ```
 ---
 ## 3. 카테고리 체계
 ### 3.1 대분류 (Level 1)
 | category_code | category_name | key_prefix | 설명 |
 |---------------|---------------|------------|------|
 | COMMON | 공통 | common | 범용 텍스트 |
 | BUTTON | 버튼 | button | 버튼 텍스트 |
 | FORM | 폼 | form | 폼 라벨, 플레이스홀더 |
 | TABLE | 테이블 | table | 테이블 헤더, 빈 상태 |
 | MESSAGE | 메시지 | message | 알림, 경고, 성공 메시지 |
 | MENU | 메뉴 | menu | 메뉴명, 네비게이션 |
 | MODAL | 모달 | modal | 모달/다이얼로그 |
 | VALIDATION | 검증 | validation | 유효성 검사 메시지 |
 | STATUS | 상태 | status | 상태 표시 텍스트 |
 | TOOLTIP | 툴팁 | tooltip | 툴팁, 도움말 |
 ### 3.2 세부분류 (Level 2)
 #### BUTTON 하위
 | category_code | category_name | key_prefix |
 |---------------|---------------|------------|
 | ACTION | 액션 | action |
 | NAVIGATION | 네비게이션 | nav |
 | TOGGLE | 토글 | toggle |
 #### FORM 하위
 | category_code | category_name | key_prefix |
 |---------------|---------------|------------|
 | LABEL | 라벨 | label |
 | PLACEHOLDER | 플레이스홀더 | placeholder |
 | HELPER | 도움말 | helper |
 #### MESSAGE 하위
 | category_code | category_name | key_prefix |
 |---------------|---------------|------------|
 | SUCCESS | 성공 | success |
 | ERROR | 에러 | error |
 | WARNING | 경고 | warning |
 | INFO | 안내 | info |
 | CONFIRM | 확인 | confirm |
 #### TABLE 하위
 | category_code | category_name | key_prefix |
 |---------------|---------------|------------|
 | HEADER | 헤더 | header |
 | EMPTY | 빈 상태 | empty |
 | PAGINATION | 페이지네이션 | pagination |
 #### MENU 하위
 | category_code | category_name | key_prefix |
 |---------------|---------------|------------|
 | ADMIN | 관리자 | admin |
 | USER | 사용자 | user |
 #### MODAL 하위
 | category_code | category_name | key_prefix |
 |---------------|---------------|------------|
 | TITLE | 제목 | title |
 | DESCRIPTION | 설명 | description |
 ### 3.3 키 자동 생성 규칙
 **형식**: `{대분류_prefix}.{세부분류_prefix}.{key_meaning}`
 **예시**:
 | 대분류 | 세부분류 | 의미 입력 | 생성 키 |
 |--------|----------|----------|---------|
 | BUTTON | ACTION | save | `button.action.save` |
 | BUTTON | ACTION | delete_selected | `button.action.delete_selected` |
 | FORM | LABEL | user_name | `form.label.user_name` |
 | FORM | PLACEHOLDER | search | `form.placeholder.search` |
 | MESSAGE | SUCCESS | save_complete | `message.success.save_complete` |
 | MESSAGE | ERROR | network_fail | `message.error.network_fail` |
 | TABLE | HEADER | created_date | `table.header.created_date` |
 | MENU | ADMIN | user_management | `menu.admin.user_management` |
 ---
 ## 4. 회사별 다국어 시스템
 ### 4.1 조회 우선순위
 다국어 텍스트 조회 시 다음 우선순위를 적용합니다:
 1. **회사 전용 키** (`company_code = 'COMPANY_A'`)
 2. **공통 키** (`company_code = '*'`)
 ```sql
 -- 조회 쿼리 예시
 WITH ranked_keys AS (
  SELECT 
    km.lang_key,
    mt.lang_text,
    km.company_code,
    ROW_NUMBER() OVER (
      PARTITION BY km.lang_key 
      ORDER BY CASE WHEN km.company_code = $1 THEN 1 ELSE 2 END
    ) as priority
  FROM multi_lang_key_master km
  JOIN multi_lang_text mt ON km.key_id = mt.key_id
  WHERE km.lang_key = ANY($2)
    AND mt.lang_code = $3
    AND km.is_active = 'Y'
    AND km.company_code IN ($1, '*')
 )
 SELECT lang_key, lang_text 
 FROM ranked_keys 
 WHERE priority = 1;
 ```
 ### 4.2 오버라이드 프로세스
 1. 회사 관리자가 공통 키에서 "이 회사 전용으로 복사" 클릭
 2. 시스템이 `base_key_id`에 원본 키를 참조하는 새 키 생성
 3. 기존 번역 텍스트 복사
 4. 회사 관리자가 번역 수정
 5. 이후 해당 회사 사용자는 회사 전용 번역 사용
 ### 4.3 권한 매트릭스
 | 작업 | 최고 관리자 (`*`) | 회사 관리자 | 일반 사용자 |
 |------|------------------|-------------|-------------|
 | 공통 키 조회 | O | O | O |
 | 공통 키 생성 | O | X | X |
 | 공통 키 수정 | O | X | X |
 | 공통 키 삭제 | O | X | X |
 | 회사 키 조회 | O | 자사만 | 자사만 |
 | 회사 키 생성 (오버라이드) | O | O | X |
 | 회사 키 수정 | O | 자사만 | X |
 | 회사 키 삭제 | O | 자사만 | X |
 | 카테고리 관리 | O | X | X |
 ---
 ## 5. API 설계
 ### 5.1 카테고리 API
 | 엔드포인트 | 메서드 | 설명 | 권한 |
 |-----------|--------|------|------|
 | `/multilang/categories` | GET | 카테고리 목록 조회 | 인증 필요 |
 | `/multilang/categories/tree` | GET | 계층 구조로 조회 | 인증 필요 |
 | `/multilang/categories` | POST | 카테고리 생성 | 최고 관리자 |
 | `/multilang/categories/:id` | PUT | 카테고리 수정 | 최고 관리자 |
 | `/multilang/categories/:id` | DELETE | 카테고리 삭제 | 최고 관리자 |
 ### 5.2 다국어 키 API (개선)
 | 엔드포인트 | 메서드 | 설명 | 권한 |
 |-----------|--------|------|------|
 | `/multilang/keys` | GET | 키 목록 조회 (카테고리/회사 필터) | 인증 필요 |
 | `/multilang/keys` | POST | 키 생성 | 공통: 최고관리자, 회사: 회사관리자 |
 | `/multilang/keys/:keyId` | PUT | 키 수정 | 공통: 최고관리자, 회사: 해당회사 |
 | `/multilang/keys/:keyId` | DELETE | 키 삭제 | 공통: 최고관리자, 회사: 해당회사 |
 | `/multilang/keys/:keyId/override` | POST | 공통 키를 회사 전용으로 복사 | 회사 관리자 |
 | `/multilang/keys/check` | GET | 키 중복 체크 | 인증 필요 |
 | `/multilang/keys/generate-preview` | POST | 키 자동 생성 미리보기 | 인증 필요 |
 ### 5.3 API 요청/응답 예시
 #### 키 생성 요청
 ```json
 POST /multilang/keys
 {
  "categoryId": 11,           // 세부분류 ID (BUTTON > ACTION)
  "keyMeaning": "save_changes",
  "description": "변경사항 저장 버튼",
  "usageNote": "사용자 관리, 설정 화면",
  "texts": [
    { "langCode": "KR", "langText": "저장하기" },
    { "langCode": "US", "langText": "Save Changes" },
    { "langCode": "JP", "langText": "保存する" }
  ]
 }
 ```
 #### 키 생성 응답
 ```json
 {
  "success": true,
  "message": "다국어 키가 생성되었습니다.",
  "data": {
    "keyId": 175,
    "langKey": "button.action.save_changes",
    "companyCode": "*",
    "categoryId": 11
  }
 }
 ```
 #### 오버라이드 요청
 ```json
 POST /multilang/keys/123/override
 {
  "texts": [
    { "langCode": "KR", "langText": "등록하기" },
    { "langCode": "US", "langText": "Register" }
  ]
 }
 ```
 ---
 ## 6. 프론트엔드 UI 설계
 ### 6.1 다국어 관리 페이지 리뉴얼
 ```
 ┌─────────────────────────────────────────────────────────────────────────┐
 │ 다국어 관리                                                              │
 │ 다국어 키와 번역 텍스트를 관리합니다                                       │
 ├─────────────────────────────────────────────────────────────────────────┤
 │ [언어 관리] [다국어 키 관리] [카테고리 관리]                               │
 ├─────────────────────────────────────────────────────────────────────────┤
 │                                                                         │
 │ ┌────────────────────┐  ┌───────────────────────────────────────────────┤
 │ │ 카테고리 필터       │  │                                               │
 │ │                    │  │ 검색: [________________] 회사: [전체 ▼]        │
 │ │ ▼ 버튼 (45)        │  │                           [초기화] [+ 키 등록] │
 │ │   ├ 액션 (30)      │  │───────────────────────────────────────────────│
 │ │   ├ 네비게이션 (10)│  │ ☐ │ 키           │ 카테고리   │ 회사 │ 상태   │
 │ │   └ 토글 (5)       │  │───────────────────────────────────────────────│
 │ │ ▼ 폼 (60)          │  │ ☐ │ button.action.save      │ 버튼>액션  │ 공통 │ 활성 │
 │ │   ├ 라벨 (35)      │  │ ☐ │ button.action.save      │ 버튼>액션  │ A사  │ 활성 │
 │ │   ├ 플레이스홀더(15)│  │ ☐ │ button.action.delete    │ 버튼>액션  │ 공통 │ 활성 │
 │ │   └ 도움말 (10)    │  │ ☐ │ form.label.user_name    │ 폼>라벨    │ 공통 │ 활성 │
 │ │ ▶ 메시지 (40)      │  │───────────────────────────────────────────────│
 │ │ ▶ 테이블 (20)      │  │ 페이지: [1] [2] [3] ... [10]                  │
 │ │ ▶ 메뉴 (9)         │  │                                               │
 │ └────────────────────┘  └───────────────────────────────────────────────┤
 └─────────────────────────────────────────────────────────────────────────┘
 ```
 ### 6.2 키 등록 모달
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │ 다국어 키 등록                                                   │
 ├─────────────────────────────────────────────────────────────────┤
 │                                                                 │
 │ ① 카테고리 선택                                                  │
 │ ┌───────────────────────────────────────────────────────────────┤
 │ │ 대분류 *                      │ 세부 분류 *                    │
 │ │ ┌─────────────────────────┐   │ ┌─────────────────────────┐   │
 │ │ │ 공통                    │   │ │ (대분류 먼저 선택)       │   │
 │ │ │ ● 버튼                  │   │ │ ● 액션                  │   │
 │ │ │ 폼                      │   │ │ 네비게이션               │   │
 │ │ │ 테이블                  │   │ │ 토글                    │   │
 │ │ │ 메시지                  │   │ │                         │   │
 │ │ └─────────────────────────┘   │ └─────────────────────────┘   │
 │ └───────────────────────────────────────────────────────────────┤
 │                                                                 │
 │ ② 키 정보 입력                                                   │
 │ ┌───────────────────────────────────────────────────────────────┤
 │ │ 키 의미 (영문) *                                               │
 │ │ [ save_changes                                         ]      │
 │ │ 영문 소문자, 밑줄(_) 사용. 예: save, add_new, delete_all       │
 │ │                                                               │
 │ │ ─────────────────────────────────────────────────────────     │
 │ │ 자동 생성 키:                                                  │
 │ │ ┌─────────────────────────────────────────────────────────┐   │
 │ │ │ button.action.save_changes                              │   │
 │ │ └─────────────────────────────────────────────────────────┘   │
 │ │ ✓ 사용 가능한 키입니다                                         │
 │ └───────────────────────────────────────────────────────────────┤
 │                                                                 │
 │ ③ 설명 및 번역                                                   │
 │ ┌───────────────────────────────────────────────────────────────┤
 │ │ 설명 (선택)                                                    │
 │ │ [ 변경사항을 저장하는 버튼                              ]      │
 │ │                                                               │
 │ │ 사용 위치 메모 (선택)                                          │
 │ │ [ 사용자 관리, 설정 화면                                ]      │
 │ │                                                               │
 │ │ ─────────────────────────────────────────────────────────     │
 │ │ 번역 텍스트                                                    │
 │ │                                                               │
 │ │ 한국어 (KR) *           [ 저장하기                      ]      │
 │ │ English (US)            [ Save Changes                  ]      │
 │ │ 日本語 (JP)             [ 保存する                      ]      │
 │ └───────────────────────────────────────────────────────────────┤
 │                                                                 │
 ├─────────────────────────────────────────────────────────────────┤
 │                                         [취소]  [등록]           │
 └─────────────────────────────────────────────────────────────────┘
 ```
 ### 6.3 공통 키 편집 모달 (회사 관리자용)
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │ 다국어 키 상세                                                   │
 │ button.action.save (공통)                                       │
 ├─────────────────────────────────────────────────────────────────┤
 │                                                                 │
 │ 카테고리: 버튼 > 액션                                            │
 │ 설명: 저장 버튼                                                  │
 │                                                                 │
 │ ─────────────────────────────────────────────────────────────   │
 │ 번역 텍스트 (읽기 전용)                                          │
 │                                                                 │
 │ 한국어 (KR)          저장                                        │
 │ English (US)         Save                                        │
 │ 日本語 (JP)          保存                                        │
 │                                                                 │
 ├─────────────────────────────────────────────────────────────────┤
 │ 공통 키는 수정할 수 없습니다.                                     │
 │ 이 회사만의 번역이 필요하시면 아래 버튼을 클릭하세요.              │
 │                                                                 │
 │                    [이 회사 전용으로 복사]                        │
 ├─────────────────────────────────────────────────────────────────┤
 │                                               [닫기]             │
 └─────────────────────────────────────────────────────────────────┘
 ```
 ### 6.4 회사 전용 키 생성 모달 (오버라이드)
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │ 회사 전용 키 생성                                                │
 ├─────────────────────────────────────────────────────────────────┤
 │                                                                 │
 │ 원본 키: button.action.save (공통)                               │
 │                                                                 │
 │ 원본 번역:                                                       │
 │ ┌─────────────────────────────────────────────────────────────┐ │
 │ │ 한국어: 저장                                                 │ │
 │ │ English: Save                                                │ │
 │ │ 日本語: 保存                                                 │ │
 │ └─────────────────────────────────────────────────────────────┘ │
 │                                                                 │
 │ ─────────────────────────────────────────────────────────────   │
 │                                                                 │
 │ 이 회사 전용 번역 텍스트:                                        │
 │                                                                 │
 │ 한국어 (KR) *           [ 등록하기                        ]      │
 │ English (US)            [ Register                        ]      │
 │ 日本語 (JP)             [ 登録                            ]      │
 │                                                                 │
 ├─────────────────────────────────────────────────────────────────┤
 │ 회사 전용 키를 생성하면 공통 키 대신 사용됩니다.                   │
 │ 원본 키가 변경되어도 회사 전용 키는 영향받지 않습니다.             │
 ├─────────────────────────────────────────────────────────────────┤
 │                                         [취소]  [생성]           │
 └─────────────────────────────────────────────────────────────────┘
 ```
 ---
 ## 7. 구현 계획
 ### 7.1 Phase 1: 데이터베이스 마이그레이션
 **예상 소요 시간: 2시간**
 1. 카테고리 테이블 생성
 2. 기본 카테고리 데이터 삽입 (대분류 10개, 세부분류 약 20개)
 3. multi_lang_key_master 스키마 변경
 4. 기존 174개 키 카테고리 자동 분류 (패턴 매칭)
 **마이그레이션 파일**: `db/migrations/075_multilang_category_system.sql`
 ### 7.2 Phase 2: 백엔드 API 개발
 **예상 소요 시간: 4시간**
 1. 카테고리 CRUD API
 2. 키 조회 로직 수정 (우선순위 적용)
 3. 권한 검사 미들웨어
 4. 오버라이드 API
 5. 키 중복 체크 API
 6. 키 자동 생성 미리보기 API
 **관련 파일**:
 - `backend-node/src/controllers/multilangController.ts`
 - `backend-node/src/services/multilangService.ts`
 - `backend-node/src/routes/multilangRoutes.ts`
 ### 7.3 Phase 3: 프론트엔드 UI 개발
 **예상 소요 시간: 6시간**
 1. 카테고리 트리 컴포넌트
 2. 키 등록 모달 리뉴얼 (단계별 입력)
 3. 키 편집 모달 (권한별 UI 분기)
 4. 오버라이드 모달
 5. 카테고리 관리 탭 추가
 **관련 파일**:
 - `frontend/app/(main)/admin/systemMng/i18nList/page.tsx`
 - `frontend/components/multilang/LangKeyModal.tsx` (리뉴얼)
 - `frontend/components/multilang/CategoryTree.tsx` (신규)
 - `frontend/components/multilang/OverrideModal.tsx` (신규)
 ### 7.4 Phase 4: 테스트 및 마이그레이션
 **예상 소요 시간: 2시간**
 1. API 테스트
 2. UI 테스트
 3. 기존 데이터 마이그레이션 검증
 4. 권한 테스트 (최고 관리자, 회사 관리자)
 ---
 ## 8. 상세 구현 일정
 | 단계 | 작업 | 예상 시간 | 의존성 |
 |------|------|----------|--------|
 | 1.1 | 마이그레이션 SQL 작성 | 30분 | - |
 | 1.2 | 카테고리 기본 데이터 삽입 | 30분 | 1.1 |
 | 1.3 | 기존 키 카테고리 자동 분류 | 30분 | 1.2 |
 | 1.4 | 스키마 변경 검증 | 30분 | 1.3 |
 | 2.1 | 카테고리 API 개발 | 1시간 | 1.4 |
 | 2.2 | 키 조회 로직 수정 (우선순위) | 1시간 | 2.1 |
 | 2.3 | 권한 검사 로직 추가 | 30분 | 2.2 |
 | 2.4 | 오버라이드 API 개발 | 1시간 | 2.3 |
 | 2.5 | 키 생성 API 개선 (자동 생성) | 30분 | 2.4 |
 | 3.1 | 카테고리 트리 컴포넌트 | 1시간 | 2.5 |
 | 3.2 | 키 등록 모달 리뉴얼 | 2시간 | 3.1 |
 | 3.3 | 키 편집/상세 모달 | 1시간 | 3.2 |
 | 3.4 | 오버라이드 모달 | 1시간 | 3.3 |
 | 3.5 | 카테고리 관리 탭 | 1시간 | 3.4 |
 | 4.1 | 통합 테스트 | 1시간 | 3.5 |
 | 4.2 | 버그 수정 및 마무리 | 1시간 | 4.1 |
 **총 예상 시간: 약 14시간**
 ---
 ## 9. 기대 효과
 ### 9.1 개선 전후 비교
 | 항목 | 현재 | 개선 후 |
 |------|------|---------|
 | 키 명명 규칙 | 불규칙 (수동 입력) | 규칙화 (자동 생성) |
 | 카테고리 분류 | 없음 | 2단계 계층 구조 |
 | 회사별 다국어 | 미활용 | 오버라이드 지원 |
 | 조회 우선순위 | 없음 | 회사 전용 > 공통 |
 | 권한 관리 | 없음 | 역할별 접근 제어 |
 | 중복 체크 | 저장 시에만 | 실시간 검증 |
 | 검색/필터 | 키 이름만 | 카테고리 + 회사 + 키 |
 ### 9.2 사용자 경험 개선
 1. **일관된 키 명명**: 자동 생성으로 규칙 준수
 2. **빠른 검색**: 카테고리 기반 필터링
 3. **회사별 커스터마이징**: 브랜드에 맞는 번역 사용
 4. **안전한 수정**: 권한 기반 보호
 ### 9.3 유지보수 개선
 1. **체계적 분류**: 어떤 텍스트가 어디에 사용되는지 명확
 2. **변경 영향 파악**: 오버라이드 추적으로 영향 범위 확인
 3. **권한 분리**: 공통 키 보호, 회사별 자율성 보장
 ---
 ## 10. 참고 자료
 ### 10.1 관련 파일
 | 파일 | 설명 |
 |------|------|
 | `frontend/hooks/useMultiLang.ts` | 다국어 훅 |
 | `frontend/lib/utils/multilang.ts` | 다국어 유틸리티 |
 | `frontend/app/(main)/admin/systemMng/i18nList/page.tsx` | 다국어 관리 페이지 |
 | `backend-node/src/controllers/multilangController.ts` | API 컨트롤러 |
 | `backend-node/src/services/multilangService.ts` | 비즈니스 로직 |
 | `docs/다국어_시스템_가이드.md` | 기존 시스템 가이드 |
 ### 10.2 데이터베이스 테이블
 | 테이블 | 설명 |
 |--------|------|
 | `language_master` | 언어 마스터 (KR, US, JP) |
 | `multi_lang_key_master` | 다국어 키 마스터 |
 | `multi_lang_text` | 다국어 번역 텍스트 |
 | `multi_lang_category` | 다국어 카테고리 (신규) |
 ---
 ## 11. 변경 이력
 | 버전 | 날짜 | 작성자 | 변경 내용 |
 |------|------|--------|----------|
 | 1.0 | 2026-01-13 | AI | 최초 작성 |
--- a/docs/메일발송_기능_사용_가이드.md
+++ b/docs/메일발송_기능_사용_가이드.md
@ -360,5 +360,3 @@
--- a/docs/즉시저장_버튼_액션_구현_계획서.md
+++ b/docs/즉시저장_버튼_액션_구현_계획서.md
@ -346,5 +346,3 @@ const getComponentValue = (componentId: string) => {
--- a/docs/화면관계_시각화_개선_보고서.md
+++ b/docs/화면관계_시각화_개선_보고서.md
--- a/docs/화면설정모달_개선_완료_보고서.md
+++ b/docs/화면설정모달_개선_완료_보고서.md
--- a/frontend/app/(main)/admin/automaticMng/batchmngList/create/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/batchmngList/create/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/batchmngList/edit/[id]/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/batchmngList/edit/[id]/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/batchmngList/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/batchmngList/page.tsx
--- a/frontend/app/(main)/admin/systemMng/collection-managementList/page.tsx
+++ b/frontend/app/(main)/admin/systemMng/collection-managementList/page.tsx
--- a/frontend/app/(main)/admin/systemMng/commonCodeList/page.tsx
+++ b/frontend/app/(main)/admin/systemMng/commonCodeList/page.tsx
--- a/frontend/app/(main)/admin/company/[companyCode]/departments/page.tsx
+++ b/frontend/app/(main)/admin/company/[companyCode]/departments/page.tsx
@ -0,0 +1,12 @@
 "use client";
 import { useParams } from "next/navigation";
 import { DepartmentManagement } from "@/components/admin/department/DepartmentManagement";
 export default function DepartmentManagementPage() {
  const params = useParams();
  const companyCode = params.companyCode as string;
  return <DepartmentManagement companyCode={companyCode} />;
 }
--- a/frontend/app/(main)/admin/company/page.tsx
+++ b/frontend/app/(main)/admin/company/page.tsx
@ -0,0 +1,25 @@
 import { CompanyManagement } from "@/components/admin/CompanyManagement";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 회사 관리 페이지
 */
 export default function CompanyPage() {
  return (
    <div className="flex min-h-screen flex-col bg-background">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">회사 관리</h1>
          <p className="text-sm text-muted-foreground">시스템에서 사용하는 회사 정보를 관리합니다</p>
        </div>
        {/* 메인 컨텐츠 */}
        <CompanyManagement />
      </div>
      {/* Scroll to Top 버튼 */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/dashboard/DashboardListClient.tsx
+++ b/frontend/app/(main)/admin/dashboard/DashboardListClient.tsx
@ -0,0 +1,449 @@
 "use client";
 import { useState, useEffect } from "react";
 import { useRouter } from "next/navigation";
 import { dashboardApi } from "@/lib/api/dashboard";
 import { Dashboard } from "@/lib/api/dashboard";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
 import {
  DropdownMenu,
  DropdownMenuContent,
  DropdownMenuItem,
  DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { useToast } from "@/hooks/use-toast";
 import { Pagination, PaginationInfo } from "@/components/common/Pagination";
 import { DeleteConfirmModal } from "@/components/common/DeleteConfirmModal";
 import { Plus, Search, Edit, Trash2, Copy, MoreVertical, AlertCircle, RefreshCw } from "lucide-react";
 /**
 * 대시보드 목록 클라이언트 컴포넌트
 * - CSR 방식으로 초기 데이터 로드
 * - 대시보드 목록 조회
 * - 대시보드 생성/수정/삭제/복사
 */
 export default function DashboardListClient() {
  const router = useRouter();
  const { toast } = useToast();
  // 상태 관리
  const [dashboards, setDashboards] = useState<Dashboard[]>([]);
  const [loading, setLoading] = useState(true); // CSR이므로 초기 로딩 true
  const [error, setError] = useState<string | null>(null);
  const [searchTerm, setSearchTerm] = useState("");
  // 페이지네이션 상태
  const [currentPage, setCurrentPage] = useState(1);
  const [pageSize, setPageSize] = useState(10);
  const [totalCount, setTotalCount] = useState(0);
  // 모달 상태
  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
  const [deleteTarget, setDeleteTarget] = useState<{ id: string; title: string } | null>(null);
  // 대시보드 목록 로드
  const loadDashboards = async () => {
    try {
      setLoading(true);
      setError(null);
      const result = await dashboardApi.getMyDashboards({
        search: searchTerm,
        page: currentPage,
        limit: pageSize,
      });
      setDashboards(result.dashboards);
      setTotalCount(result.pagination.total);
    } catch (err) {
      console.error("Failed to load dashboards:", err);
      setError(
        err instanceof Error
          ? err.message
          : "대시보드 목록을 불러오는데 실패했습니다. 네트워크 연결을 확인하거나 잠시 후 다시 시도해주세요.",
      );
    } finally {
      setLoading(false);
    }
  };
  // 검색어/페이지 변경 시 fetch (초기 로딩 포함)
  useEffect(() => {
    loadDashboards();
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [searchTerm, currentPage, pageSize]);
  // 페이지네이션 정보 계산
  const paginationInfo: PaginationInfo = {
    currentPage,
    totalPages: Math.ceil(totalCount / pageSize) || 1,
    totalItems: totalCount,
    itemsPerPage: pageSize,
    startItem: totalCount === 0 ? 0 : (currentPage - 1) * pageSize + 1,
    endItem: Math.min(currentPage * pageSize, totalCount),
  };
  // 페이지 변경 핸들러
  const handlePageChange = (page: number) => {
    setCurrentPage(page);
  };
  // 페이지 크기 변경 핸들러
  const handlePageSizeChange = (size: number) => {
    setPageSize(size);
    setCurrentPage(1); // 페이지 크기 변경 시 첫 페이지로
  };
  // 대시보드 삭제 확인 모달 열기
  const handleDeleteClick = (id: string, title: string) => {
    setDeleteTarget({ id, title });
    setDeleteDialogOpen(true);
  };
  // 대시보드 삭제 실행
  const handleDeleteConfirm = async () => {
    if (!deleteTarget) return;
    try {
      await dashboardApi.deleteDashboard(deleteTarget.id);
      setDeleteDialogOpen(false);
      setDeleteTarget(null);
      toast({
        title: "성공",
        description: "대시보드가 삭제되었습니다.",
      });
      loadDashboards();
    } catch (err) {
      console.error("Failed to delete dashboard:", err);
      setDeleteDialogOpen(false);
      toast({
        title: "오류",
        description: "대시보드 삭제에 실패했습니다.",
        variant: "destructive",
      });
    }
  };
  // 대시보드 복사
  const handleCopy = async (dashboard: Dashboard) => {
    try {
      const fullDashboard = await dashboardApi.getDashboard(dashboard.id);
      await dashboardApi.createDashboard({
        title: `${fullDashboard.title} (복사본)`,
        description: fullDashboard.description,
        elements: fullDashboard.elements || [],
        isPublic: false,
        tags: fullDashboard.tags,
        category: fullDashboard.category,
        settings: fullDashboard.settings as { resolution?: string; backgroundColor?: string },
      });
      toast({
        title: "성공",
        description: "대시보드가 복사되었습니다.",
      });
      loadDashboards();
    } catch (err) {
      console.error("Failed to copy dashboard:", err);
      toast({
        title: "오류",
        description: "대시보드 복사에 실패했습니다.",
        variant: "destructive",
      });
    }
  };
  // 포맷팅 헬퍼
  const formatDate = (dateString: string) => {
    return new Date(dateString).toLocaleDateString("ko-KR", {
      year: "numeric",
      month: "2-digit",
      day: "2-digit",
    });
  };
  return (
    <>
      {/* 검색 및 액션 */}
      <div className="flex flex-col gap-4 lg:flex-row lg:items-center lg:justify-between">
        <div className="flex items-center gap-4">
          <div className="relative w-full sm:w-[300px]">
            <Search className="text-muted-foreground absolute top-1/2 left-3 h-4 w-4 -translate-y-1/2" />
            <Input
              placeholder="대시보드 검색..."
              value={searchTerm}
              onChange={(e) => setSearchTerm(e.target.value)}
              className="h-10 pl-10 text-sm"
            />
          </div>
          <div className="text-muted-foreground text-sm">
            총 <span className="text-foreground font-semibold">{totalCount.toLocaleString()}</span> 건
          </div>
        </div>
        <Button onClick={() => router.push("/admin/dashboard/new")} className="h-10 gap-2 text-sm font-medium">
          <Plus className="h-4 w-4" />새 대시보드 생성
        </Button>
      </div>
      {/* 대시보드 목록 */}
      {loading ? (
        <>
          {/* 데스크톱 테이블 스켈레톤 */}
          <div className="bg-card hidden shadow-sm lg:block">
            <Table>
              <TableHeader>
                <TableRow className="bg-muted/50 hover:bg-muted/50 border-b">
                  <TableHead className="h-12 text-sm font-semibold">제목</TableHead>
                  <TableHead className="h-12 text-sm font-semibold">설명</TableHead>
                  <TableHead className="h-12 text-sm font-semibold">생성자</TableHead>
                  <TableHead className="h-12 text-sm font-semibold">생성일</TableHead>
                  <TableHead className="h-12 text-sm font-semibold">수정일</TableHead>
                  <TableHead className="h-12 text-right text-sm font-semibold">작업</TableHead>
                </TableRow>
              </TableHeader>
              <TableBody>
                {Array.from({ length: 10 }).map((_, index) => (
                  <TableRow key={index} className="border-b">
                    <TableCell className="h-16">
                      <div className="bg-muted h-4 animate-pulse rounded"></div>
                    </TableCell>
                    <TableCell className="h-16">
                      <div className="bg-muted h-4 animate-pulse rounded"></div>
                    </TableCell>
                    <TableCell className="h-16">
                      <div className="bg-muted h-4 w-20 animate-pulse rounded"></div>
                    </TableCell>
                    <TableCell className="h-16">
                      <div className="bg-muted h-4 w-24 animate-pulse rounded"></div>
                    </TableCell>
                    <TableCell className="h-16">
                      <div className="bg-muted h-4 w-24 animate-pulse rounded"></div>
                    </TableCell>
                    <TableCell className="h-16 text-right">
                      <div className="bg-muted ml-auto h-8 w-8 animate-pulse rounded"></div>
                    </TableCell>
                  </TableRow>
                ))}
              </TableBody>
            </Table>
          </div>
          {/* 모바일/태블릿 카드 스켈레톤 */}
          <div className="grid gap-4 sm:grid-cols-2 lg:hidden">
            {Array.from({ length: 6 }).map((_, index) => (
              <div key={index} className="bg-card rounded-lg border p-4 shadow-sm">
                <div className="mb-4 flex items-start justify-between">
                  <div className="flex-1 space-y-2">
                    <div className="bg-muted h-5 w-32 animate-pulse rounded"></div>
                    <div className="bg-muted h-4 w-24 animate-pulse rounded"></div>
                  </div>
                </div>
                <div className="space-y-2 border-t pt-4">
                  {Array.from({ length: 3 }).map((_, i) => (
                    <div key={i} className="flex justify-between">
                      <div className="bg-muted h-4 w-16 animate-pulse rounded"></div>
                      <div className="bg-muted h-4 w-32 animate-pulse rounded"></div>
                    </div>
                  ))}
                </div>
              </div>
            ))}
          </div>
        </>
      ) : error ? (
        <div className="border-destructive/50 bg-destructive/10 flex flex-col items-center justify-center rounded-lg border p-12">
          <div className="flex flex-col items-center gap-4 text-center">
            <div className="bg-destructive/20 flex h-16 w-16 items-center justify-center rounded-full">
              <AlertCircle className="text-destructive h-8 w-8" />
            </div>
            <div>
              <h3 className="text-destructive mb-2 text-lg font-semibold">데이터를 불러올 수 없습니다</h3>
              <p className="text-destructive/80 max-w-md text-sm">{error}</p>
            </div>
            <Button onClick={loadDashboards} variant="outline" className="mt-2 gap-2">
              <RefreshCw className="h-4 w-4" />
              다시 시도
            </Button>
          </div>
        </div>
      ) : dashboards.length === 0 ? (
        <div className="bg-card flex h-64 flex-col items-center justify-center shadow-sm">
          <div className="flex flex-col items-center gap-2 text-center">
            <p className="text-muted-foreground text-sm">대시보드가 없습니다</p>
          </div>
        </div>
      ) : (
        <>
          {/* 데스크톱 테이블 뷰 (lg 이상) */}
          <div className="bg-card hidden shadow-sm lg:block">
            <Table>
              <TableHeader>
                <TableRow className="bg-muted/50 hover:bg-muted/50 border-b">
                  <TableHead className="h-12 text-sm font-semibold">제목</TableHead>
                  <TableHead className="h-12 text-sm font-semibold">설명</TableHead>
                  <TableHead className="h-12 text-sm font-semibold">생성자</TableHead>
                  <TableHead className="h-12 text-sm font-semibold">생성일</TableHead>
                  <TableHead className="h-12 text-sm font-semibold">수정일</TableHead>
                  <TableHead className="h-12 text-right text-sm font-semibold">작업</TableHead>
                </TableRow>
              </TableHeader>
              <TableBody>
                {dashboards.map((dashboard) => (
                  <TableRow key={dashboard.id} className="hover:bg-muted/50 border-b transition-colors">
                    <TableCell className="h-16 text-sm font-medium">
                      <button
                        onClick={() => router.push(`/admin/dashboard/edit/${dashboard.id}`)}
                        className="hover:text-primary cursor-pointer text-left transition-colors hover:underline"
                      >
                        {dashboard.title}
                      </button>
                    </TableCell>
                    <TableCell className="text-muted-foreground h-16 max-w-md truncate text-sm">
                      {dashboard.description || "-"}
                    </TableCell>
                    <TableCell className="text-muted-foreground h-16 text-sm">
                      {dashboard.createdByName || dashboard.createdBy || "-"}
                    </TableCell>
                    <TableCell className="text-muted-foreground h-16 text-sm">
                      {formatDate(dashboard.createdAt)}
                    </TableCell>
                    <TableCell className="text-muted-foreground h-16 text-sm">
                      {formatDate(dashboard.updatedAt)}
                    </TableCell>
                    <TableCell className="h-16 text-right">
                      <DropdownMenu>
                        <DropdownMenuTrigger asChild>
                          <Button variant="ghost" size="icon" className="h-8 w-8">
                            <MoreVertical className="h-4 w-4" />
                          </Button>
                        </DropdownMenuTrigger>
                        <DropdownMenuContent align="end">
                          <DropdownMenuItem
                            onClick={() => router.push(`/admin/dashboard/edit/${dashboard.id}`)}
                            className="gap-2 text-sm"
                          >
                            <Edit className="h-4 w-4" />
                            편집
                          </DropdownMenuItem>
                          <DropdownMenuItem onClick={() => handleCopy(dashboard)} className="gap-2 text-sm">
                            <Copy className="h-4 w-4" />
                            복사
                          </DropdownMenuItem>
                          <DropdownMenuItem
                            onClick={() => handleDeleteClick(dashboard.id, dashboard.title)}
                            className="text-destructive focus:text-destructive gap-2 text-sm"
                          >
                            <Trash2 className="h-4 w-4" />
                            삭제
                          </DropdownMenuItem>
                        </DropdownMenuContent>
                      </DropdownMenu>
                    </TableCell>
                  </TableRow>
                ))}
              </TableBody>
            </Table>
          </div>
          {/* 모바일/태블릿 카드 뷰 (lg 미만) */}
          <div className="grid gap-4 sm:grid-cols-2 lg:hidden">
            {dashboards.map((dashboard) => (
              <div
                key={dashboard.id}
                className="bg-card hover:bg-muted/50 rounded-lg border p-4 shadow-sm transition-colors"
              >
                {/* 헤더 */}
                <div className="mb-4 flex items-start justify-between">
                  <div className="flex-1">
                    <button
                      onClick={() => router.push(`/admin/dashboard/edit/${dashboard.id}`)}
                      className="hover:text-primary cursor-pointer text-left transition-colors hover:underline"
                    >
                      <h3 className="text-base font-semibold">{dashboard.title}</h3>
                    </button>
                    <p className="text-muted-foreground mt-1 text-sm">{dashboard.id}</p>
                  </div>
                </div>
                {/* 정보 */}
                <div className="space-y-2 border-t pt-4">
                  <div className="flex justify-between text-sm">
                    <span className="text-muted-foreground">설명</span>
                    <span className="max-w-[200px] truncate font-medium">{dashboard.description || "-"}</span>
                  </div>
                  <div className="flex justify-between text-sm">
                    <span className="text-muted-foreground">생성자</span>
                    <span className="font-medium">{dashboard.createdByName || dashboard.createdBy || "-"}</span>
                  </div>
                  <div className="flex justify-between text-sm">
                    <span className="text-muted-foreground">생성일</span>
                    <span className="font-medium">{formatDate(dashboard.createdAt)}</span>
                  </div>
                  <div className="flex justify-between text-sm">
                    <span className="text-muted-foreground">수정일</span>
                    <span className="font-medium">{formatDate(dashboard.updatedAt)}</span>
                  </div>
                </div>
                {/* 액션 */}
                <div className="mt-4 flex gap-2 border-t pt-4">
                  <Button
                    variant="outline"
                    size="sm"
                    className="h-9 flex-1 gap-2 text-sm"
                    onClick={() => router.push(`/admin/dashboard/edit/${dashboard.id}`)}
                  >
                    <Edit className="h-4 w-4" />
                    편집
                  </Button>
                  <Button
                    variant="outline"
                    size="sm"
                    className="h-9 flex-1 gap-2 text-sm"
                    onClick={() => handleCopy(dashboard)}
                  >
                    <Copy className="h-4 w-4" />
                    복사
                  </Button>
                  <Button
                    variant="outline"
                    size="sm"
                    className="text-destructive hover:bg-destructive/10 hover:text-destructive h-9 gap-2 text-sm"
                    onClick={() => handleDeleteClick(dashboard.id, dashboard.title)}
                  >
                    <Trash2 className="h-4 w-4" />
                  </Button>
                </div>
              </div>
            ))}
          </div>
        </>
      )}
      {/* 페이지네이션 */}
      {!loading && dashboards.length > 0 && (
        <Pagination
          paginationInfo={paginationInfo}
          onPageChange={handlePageChange}
          onPageSizeChange={handlePageSizeChange}
          showPageSizeSelector={true}
          pageSizeOptions={[10, 20, 50, 100]}
        />
      )}
      {/* 삭제 확인 모달 */}
      <DeleteConfirmModal
        open={deleteDialogOpen}
        onOpenChange={setDeleteDialogOpen}
        title="대시보드 삭제"
        description={
          <>
            &quot;{deleteTarget?.title}&quot; 대시보드를 삭제하시겠습니까?
            <br />이 작업은 되돌릴 수 없습니다.
          </>
        }
        onConfirm={handleDeleteConfirm}
      />
    </>
  );
 }
--- a/frontend/app/(main)/admin/dashboard/edit/[id]/page.tsx
+++ b/frontend/app/(main)/admin/dashboard/edit/[id]/page.tsx
@ -0,0 +1,23 @@
 "use client";
 import React from "react";
 import { use } from "react";
 import DashboardDesigner from "@/components/admin/dashboard/DashboardDesigner";
 interface PageProps {
  params: Promise<{ id: string }>;
 }
 /**
 * 대시보드 편집 페이지
 * - 기존 대시보드 편집
 */
 export default function DashboardEditPage({ params }: PageProps) {
  const { id } = use(params);
  return (
    <div className="h-full">
      <DashboardDesigner dashboardId={id} />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/dashboard/new/page.tsx
+++ b/frontend/app/(main)/admin/dashboard/new/page.tsx
@ -0,0 +1,12 @@
 import DashboardDesigner from "@/components/admin/dashboard/DashboardDesigner";
 /**
 * 새 대시보드 생성 페이지
 */
 export default function DashboardNewPage() {
  return (
    <div className="h-full">
      <DashboardDesigner />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/dashboard/page.tsx
+++ b/frontend/app/(main)/admin/dashboard/page.tsx
@ -0,0 +1,23 @@
 import DashboardListClient from "@/app/(main)/admin/dashboard/DashboardListClient";
 /**
 * 대시보드 관리 페이지
 * - 클라이언트 컴포넌트를 렌더링하는 래퍼
 * - 초기 로딩부터 CSR로 처리
 */
 export default function DashboardListPage() {
  return (
    <div className="bg-background flex min-h-screen flex-col">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">대시보드 관리</h1>
          <p className="text-muted-foreground text-sm">대시보드를 생성하고 관리할 수 있습니다</p>
        </div>
        {/* 클라이언트 컴포넌트 */}
        <DashboardListClient />
      </div>
    </div>
  );
 }
--- a/frontend/app/(main)/admin/systemMng/dataflow/edit/[diagramId]/page.tsx
+++ b/frontend/app/(main)/admin/systemMng/dataflow/edit/[diagramId]/page.tsx
--- a/frontend/app/(main)/admin/systemMng/dataflow/node-editorList/page.tsx
+++ b/frontend/app/(main)/admin/systemMng/dataflow/node-editorList/page.tsx
@ -13,7 +13,7 @@ export default function NodeEditorPage() {
  useEffect(() => {
    // /admin/dataflow 메인 페이지로 리다이렉트
-    router.replace("/admin/systemMng/dataflow");
+    router.replace("/admin/dataflow");
  }, [router]);
  return (
--- a/frontend/app/(main)/admin/systemMng/dataflow/page.tsx
+++ b/frontend/app/(main)/admin/systemMng/dataflow/page.tsx
@ -51,17 +51,17 @@ export default function DataFlowPage() {
  // 에디터 모드일 때는 레이아웃 없이 전체 화면 사용
  if (isEditorMode) {
    return (
-      <div className="bg-background fixed inset-0 z-50">
+      <div className="fixed inset-0 z-50 bg-background">
        <div className="flex h-full flex-col">
          {/* 에디터 헤더 */}
-          <div className="bg-background flex items-center gap-4 border-b p-4">
+          <div className="flex items-center gap-4 border-b bg-background p-4">
            <Button variant="outline" size="sm" onClick={handleBackToList} className="flex items-center gap-2">
              <ArrowLeft className="h-4 w-4" />
              목록으로
            </Button>
            <div>
              <h1 className="text-2xl font-bold tracking-tight">노드 플로우 에디터</h1>
-              <p className="text-muted-foreground mt-1 text-sm">
+              <p className="mt-1 text-sm text-muted-foreground">
                드래그 앤 드롭으로 데이터 제어 플로우를 시각적으로 설계합니다
              </p>
            </div>
@ -77,12 +77,12 @@ export default function DataFlowPage() {
  }
  return (
-    <div className="bg-background flex min-h-screen flex-col">
+    <div className="flex min-h-screen flex-col bg-background">
      <div className="space-y-6 p-4 sm:p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">제어 관리</h1>
-          <p className="text-muted-foreground text-sm">노드 기반 데이터 플로우를 시각적으로 설계하고 관리합니다</p>
+          <p className="text-sm text-muted-foreground">노드 기반 데이터 플로우를 시각적으로 설계하고 관리합니다</p>
        </div>
        {/* 플로우 목록 */}
--- a/frontend/app/(main)/admin/automaticMng/exCallConfList/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/exCallConfList/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/exconList/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/exconList/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/flowMgmtList/[id]/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/flowMgmtList/[id]/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/flowMgmtList/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/flowMgmtList/page.tsx
--- a/frontend/app/(main)/admin/i18n/page.tsx
+++ b/frontend/app/(main)/admin/i18n/page.tsx
@ -0,0 +1,14 @@
 "use client";
 import MultiLang from "@/components/admin/MultiLang";
 export default function I18nPage() {
  return (
    <div className="min-h-screen bg-gray-50">
      <div className="w-full max-w-none px-4 py-8">
        <MultiLang />
      </div>
    </div>
  );
 }
--- a/frontend/app/(main)/admin/automaticMng/mail/accounts/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/accounts/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/mail/bulk-send/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/bulk-send/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/mail/dashboardList/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/dashboardList/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/mail/drafts/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/drafts/page.tsx
@ -51,7 +51,7 @@ export default function DraftsPage() {
      content: draft.htmlContent,
      accountId: draft.accountId,
    });
-    router.push(`/admin/automaticMng/mail/send?${params.toString()}`);
+    router.push(`/admin/mail/send?${params.toString()}`);
  };
  const handleDelete = async (id: string) => {
--- a/frontend/app/(main)/admin/automaticMng/mail/receive/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/receive/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/mail/send/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/send/page.tsx
@ -1056,7 +1056,7 @@ ${data.originalBody}`;
                        <Button
                          variant="outline"
                          size="sm"
-                          onClick={() => router.push(`/admin/automaticMng/mail/templates`)}
+                          onClick={() => router.push(`/admin/mail/templates`)}
                          className="flex items-center gap-1"
                        >
                          <Settings className="w-3 h-3" />
--- a/frontend/app/(main)/admin/automaticMng/mail/sent/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/sent/page.tsx
@ -336,7 +336,7 @@ export default function SentMailPage() {
              <RefreshCw className={`w-4 h-4 mr-2 ${loading ? "animate-spin" : ""}`} />
              새로고침
            </Button>
-            <Button onClick={() => router.push("/admin/automaticMng/mail/send")} size="sm">
+            <Button onClick={() => router.push("/admin/mail/send")} size="sm">
              <Mail className="w-4 h-4 mr-2" />
              메일 작성
            </Button>
--- a/frontend/app/(main)/admin/automaticMng/mail/templates/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/templates/page.tsx
--- a/frontend/app/(main)/admin/automaticMng/mail/trash/page.tsx
+++ b/frontend/app/(main)/admin/automaticMng/mail/trash/page.tsx
--- a/frontend/app/(main)/admin/menu/page.tsx
+++ b/frontend/app/(main)/admin/menu/page.tsx
--- a/frontend/app/(main)/admin/monitoring/page.tsx
+++ b/frontend/app/(main)/admin/monitoring/page.tsx
@ -1,124 +1,9 @@
 "use client";
-import React, { useState, useEffect } from "react";
+import React from "react";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import MonitoringDashboard from "@/components/admin/MonitoringDashboard";
 import { Button } from "@/components/ui/button";
 import { Badge } from "@/components/ui/badge";
 import {
  Table,
  TableBody,
  TableCell,
  TableHead,
  TableHeader,
  TableRow,
 } from "@/components/ui/table";
 import { Progress } from "@/components/ui/progress";
 import { RefreshCw, Play, Pause, AlertCircle, CheckCircle, Clock } from "lucide-react";
 import { toast } from "sonner";
 import { BatchAPI, BatchMonitoring } from "@/lib/api/batch";
 export default function MonitoringPage() {
  const [monitoring, setMonitoring] = useState<BatchMonitoring | null>(null);
  const [isLoading, setIsLoading] = useState(false);
  const [autoRefresh, setAutoRefresh] = useState(false);
  useEffect(() => {
    loadMonitoringData();
    let interval: NodeJS.Timeout;
    if (autoRefresh) {
      interval = setInterval(loadMonitoringData, 30000); // 30초마다 자동 새로고침
    }
    return () => {
      if (interval) clearInterval(interval);
    };
  }, [autoRefresh]);
  const loadMonitoringData = async () => {
    setIsLoading(true);
    try {
      const data = await BatchAPI.getBatchMonitoring();
      setMonitoring(data);
    } catch (error) {
      console.error("모니터링 데이터 조회 오류:", error);
      toast.error("모니터링 데이터를 불러오는데 실패했습니다.");
    } finally {
      setIsLoading(false);
    }
  };
  const handleRefresh = () => {
    loadMonitoringData();
  };
  const toggleAutoRefresh = () => {
    setAutoRefresh(!autoRefresh);
  };
  const getStatusIcon = (status: string) => {
    switch (status) {
      case 'completed':
        return <CheckCircle className="h-4 w-4 text-green-500" />;
      case 'failed':
        return <AlertCircle className="h-4 w-4 text-red-500" />;
      case 'running':
        return <Play className="h-4 w-4 text-blue-500" />;
      case 'pending':
        return <Clock className="h-4 w-4 text-yellow-500" />;
      default:
        return <Clock className="h-4 w-4 text-gray-500" />;
    }
  };
  const getStatusBadge = (status: string) => {
    const variants = {
      completed: "bg-green-100 text-green-800",
      failed: "bg-destructive/20 text-red-800",
      running: "bg-primary/20 text-blue-800",
      pending: "bg-yellow-100 text-yellow-800",
      cancelled: "bg-gray-100 text-gray-800",
    };
    const labels = {
      completed: "완료",
      failed: "실패",
      running: "실행 중",
      pending: "대기 중",
      cancelled: "취소됨",
    };
    return (
      <Badge className={variants[status as keyof typeof variants] || variants.pending}>
        {labels[status as keyof typeof labels] || status}
      </Badge>
    );
  };
  const formatDuration = (ms: number) => {
    if (ms < 1000) return `${ms}ms`;
    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
    return `${(ms / 60000).toFixed(1)}m`;
  };
  const getSuccessRate = () => {
    if (!monitoring) return 0;
    const total = monitoring.successful_jobs_today + monitoring.failed_jobs_today;
    if (total === 0) return 100;
    return Math.round((monitoring.successful_jobs_today / total) * 100);
  };
  if (!monitoring) {
    return (
      <div className="flex items-center justify-center h-64">
        <div className="text-center">
          <RefreshCw className="h-8 w-8 animate-spin mx-auto mb-2" />
          <p>모니터링 데이터를 불러오는 중...</p>
        </div>
      </div>
    );
  }
  return (
    <div className="min-h-screen bg-gray-50">
      <div className="w-full max-w-none px-4 py-8 space-y-8">
@ -131,170 +16,7 @@ export default function MonitoringPage() {
        </div>
        {/* 모니터링 대시보드 */}
-        <div className="space-y-6">
+        <MonitoringDashboard />
          {/* 헤더 */}
          <div className="flex items-center justify-between">
            <h2 className="text-2xl font-bold">배치 모니터링</h2>
            <div className="flex items-center gap-2">
              <Button
                variant="outline"
                size="sm"
                onClick={toggleAutoRefresh}
                className={autoRefresh ? "bg-accent text-primary" : ""}
              >
                {autoRefresh ? <Pause className="h-4 w-4 mr-1" /> : <Play className="h-4 w-4 mr-1" />}
                자동 새로고침
              </Button>
              <Button
                variant="outline"
                size="sm"
                onClick={handleRefresh}
                disabled={isLoading}
              >
                <RefreshCw className={`h-4 w-4 mr-1 ${isLoading ? 'animate-spin' : ''}`} />
                새로고침
              </Button>
            </div>
          </div>
          {/* 통계 카드 */}
          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
            <Card>
              <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
                <CardTitle className="text-sm font-medium">총 작업 수</CardTitle>
                <div className="text-2xl">📋</div>
              </CardHeader>
              <CardContent>
                <div className="text-2xl font-bold">{monitoring.total_jobs}</div>
                <p className="text-xs text-muted-foreground">
                  활성: {monitoring.active_jobs}개
                </p>
              </CardContent>
            </Card>
            <Card>
              <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
                <CardTitle className="text-sm font-medium">실행 중</CardTitle>
                <div className="text-2xl">🔄</div>
              </CardHeader>
              <CardContent>
                <div className="text-2xl font-bold text-primary">{monitoring.running_jobs}</div>
                <p className="text-xs text-muted-foreground">
                  현재 실행 중인 작업
                </p>
              </CardContent>
            </Card>
            <Card>
              <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
                <CardTitle className="text-sm font-medium">오늘 성공</CardTitle>
                <div className="text-2xl">✅</div>
              </CardHeader>
              <CardContent>
                <div className="text-2xl font-bold text-green-600">{monitoring.successful_jobs_today}</div>
                <p className="text-xs text-muted-foreground">
                  성공률: {getSuccessRate()}%
                </p>
              </CardContent>
            </Card>
            <Card>
              <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
                <CardTitle className="text-sm font-medium">오늘 실패</CardTitle>
                <div className="text-2xl">❌</div>
              </CardHeader>
              <CardContent>
                <div className="text-2xl font-bold text-destructive">{monitoring.failed_jobs_today}</div>
                <p className="text-xs text-muted-foreground">
                  주의가 필요한 작업
                </p>
              </CardContent>
            </Card>
          </div>
          {/* 성공률 진행바 */}
          <Card>
            <CardHeader>
              <CardTitle className="text-lg">오늘 실행 성공률</CardTitle>
            </CardHeader>
            <CardContent>
              <div className="space-y-2">
                <div className="flex justify-between text-sm">
                  <span>성공: {monitoring.successful_jobs_today}건</span>
                  <span>실패: {monitoring.failed_jobs_today}건</span>
                </div>
                <Progress value={getSuccessRate()} className="h-2" />
                <div className="text-center text-sm text-muted-foreground">
                  {getSuccessRate()}% 성공률
                </div>
              </div>
            </CardContent>
          </Card>
          {/* 최근 실행 이력 */}
          <Card>
            <CardHeader>
              <CardTitle className="text-lg">최근 실행 이력</CardTitle>
            </CardHeader>
            <CardContent>
              {monitoring.recent_executions.length === 0 ? (
                <div className="text-center py-8 text-muted-foreground">
                  최근 실행 이력이 없습니다.
                </div>
              ) : (
                <Table>
                  <TableHeader>
                    <TableRow>
                      <TableHead>상태</TableHead>
                      <TableHead>작업 ID</TableHead>
                      <TableHead>시작 시간</TableHead>
                      <TableHead>완료 시간</TableHead>
                      <TableHead>실행 시간</TableHead>
                      <TableHead>오류 메시지</TableHead>
                    </TableRow>
                  </TableHeader>
                  <TableBody>
                    {monitoring.recent_executions.map((execution) => (
                      <TableRow key={execution.id}>
                        <TableCell>
                          <div className="flex items-center gap-2">
                            {getStatusIcon(execution.execution_status)}
                            {getStatusBadge(execution.execution_status)}
                          </div>
                        </TableCell>
                        <TableCell className="font-mono">#{execution.job_id}</TableCell>
                        <TableCell>
                          {execution.started_at
                            ? new Date(execution.started_at).toLocaleString()
                            : "-"}
                        </TableCell>
                        <TableCell>
                          {execution.completed_at
                            ? new Date(execution.completed_at).toLocaleString()
                            : "-"}
                        </TableCell>
                        <TableCell>
                          {execution.execution_time_ms
                            ? formatDuration(execution.execution_time_ms)
                            : "-"}
                        </TableCell>
                        <TableCell className="max-w-xs">
                          {execution.error_message ? (
                            <span className="text-destructive text-sm truncate block">
                              {execution.error_message}
                            </span>
                          ) : (
                            "-"
                          )}
                        </TableCell>
                      </TableRow>
                    ))}
                  </TableBody>
                </Table>
              )}
            </CardContent>
          </Card>
        </div>
      </div>
    </div>
  );
--- a/frontend/app/(main)/admin/page.tsx
+++ b/frontend/app/(main)/admin/page.tsx
@ -1,4 +1,4 @@
-import { Users, Shield, Settings, BarChart3, Palette, Layout, Database, Package, Building2 } from "lucide-react";
+import { Users, Shield, Settings, BarChart3, Palette, Layout, Database, Package } from "lucide-react";
 import Link from "next/link";
 import { GlobalFileViewer } from "@/components/GlobalFileViewer";
@ -9,7 +9,6 @@ export default function AdminPage() {
  return (
    <div className="bg-background min-h-screen">
      <div className="w-full max-w-none space-y-16 px-4 pt-12 pb-16">
        {/* 주요 관리 기능 */}
        <div className="mx-auto max-w-7xl space-y-10">
          <div className="mb-8 text-center">
@ -169,7 +168,7 @@ export default function AdminPage() {
              </div>
            </Link>
-            <Link href="/admin/automaticMng/exconList" className="block">
+            <Link href="/admin/external-connections" className="block">
              <div className="bg-card hover:bg-muted rounded-lg border p-6 shadow-sm transition-colors">
                <div className="flex items-center gap-4">
                  <div className="bg-success/10 flex h-12 w-12 items-center justify-center rounded-lg">
@ -183,7 +182,7 @@ export default function AdminPage() {
              </div>
            </Link>
-            <Link href="/admin/systemMng/commonCodeList" className="block">
+            <Link href="/admin/commonCode" className="block">
              <div className="bg-card hover:bg-muted rounded-lg border p-6 shadow-sm transition-colors">
                <div className="flex items-center gap-4">
                  <div className="bg-primary/10 flex h-12 w-12 items-center justify-center rounded-lg">
--- a/frontend/app/(main)/admin/screenMng/reportList/designer/[reportId]/page.tsx
+++ b/frontend/app/(main)/admin/screenMng/reportList/designer/[reportId]/page.tsx
@ -37,7 +37,7 @@ export default function ReportDesignerPage() {
            description: "리포트를 찾을 수 없습니다.",
            variant: "destructive",
          });
-          router.push("/admin/screenMng/reportList");
+          router.push("/admin/report");
        }
      } catch (error: any) {
        toast({
@ -45,7 +45,7 @@ export default function ReportDesignerPage() {
          description: error.message || "리포트를 불러오는데 실패했습니다.",
          variant: "destructive",
        });
-        router.push("/admin/screenMng/reportList");
+        router.push("/admin/report");
      } finally {
        setIsLoading(false);
      }
--- a/frontend/app/(main)/admin/screenMng/reportList/page.tsx
+++ b/frontend/app/(main)/admin/screenMng/reportList/page.tsx
@ -26,7 +26,7 @@ export default function ReportManagementPage() {
  const handleCreateNew = () => {
    // 새 리포트는 'new'라는 특수 ID로 디자이너 진입
-    router.push("/admin/screenMng/reportList/designer/new");
+    router.push("/admin/report/designer/new");
  };
  return (
--- a/frontend/app/(main)/admin/roles/[id]/page.tsx
+++ b/frontend/app/(main)/admin/roles/[id]/page.tsx
@ -0,0 +1,30 @@
 "use client";
 import { use } from "react";
 import { RoleDetailManagement } from "@/components/admin/RoleDetailManagement";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 권한 그룹 상세 페이지
 * URL: /admin/roles/[id]
 *
 * 기능:
 * - 권한 그룹 멤버 관리 (Dual List Box)
 * - 메뉴 권한 설정 (CRUD 체크박스)
 */
 export default function RoleDetailPage({ params }: { params: Promise<{ id: string }> }) {
  // Next.js 15: params는 Promise이므로 React.use()로 unwrap
  const { id } = use(params);
  return (
    <div className="bg-background flex min-h-screen flex-col">
      <div className="space-y-6 p-6">
        {/* 메인 컨텐츠 */}
        <RoleDetailManagement roleId={id} />
      </div>
      {/* Scroll to Top 버튼 (모바일/태블릿 전용) */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/roles/page.tsx
+++ b/frontend/app/(main)/admin/roles/page.tsx
@ -0,0 +1,39 @@
 "use client";
 import { RoleManagement } from "@/components/admin/RoleManagement";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 권한 그룹 관리 페이지
 * URL: /admin/roles
 *
 * shadcn/ui 스타일 가이드 적용
 *
 * 기능:
 * - 회사별 권한 그룹 목록 조회
 * - 권한 그룹 생성/수정/삭제
 * - 멤버 관리 (Dual List Box)
 * - 메뉴 권한 설정 (CRUD 권한)
 */
 export default function RolesPage() {
  return (
    <div className="flex min-h-screen flex-col bg-background">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">권한 그룹 관리</h1>
          <p className="text-sm text-muted-foreground">
            회사 내 권한 그룹을 생성하고 멤버를 관리합니다 (회사 관리자 이상)
          </p>
        </div>
        {/* 메인 컨텐츠 */}
        <RoleManagement />
      </div>
      {/* Scroll to Top 버튼 (모바일/태블릿 전용) */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/screenMng/dashboardList/page.tsx
+++ b/frontend/app/(main)/admin/screenMng/dashboardList/page.tsx
@ -1,458 +0,0 @@
 "use client";
 import { useState, useEffect } from "react";
 import { useRouter } from "next/navigation";
 import { dashboardApi } from "@/lib/api/dashboard";
 import { Dashboard } from "@/lib/api/dashboard";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
 import {
  DropdownMenu,
  DropdownMenuContent,
  DropdownMenuItem,
  DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { useToast } from "@/hooks/use-toast";
 import { Pagination, PaginationInfo } from "@/components/common/Pagination";
 import { DeleteConfirmModal } from "@/components/common/DeleteConfirmModal";
 import { Plus, Search, Edit, Trash2, Copy, MoreVertical, AlertCircle, RefreshCw } from "lucide-react";
 /**
 * 대시보드 관리 페이지
 * - CSR 방식으로 초기 데이터 로드
 * - 대시보드 목록 조회
 * - 대시보드 생성/수정/삭제/복사
 */
 export default function DashboardListPage() {
  const router = useRouter();
  const { toast } = useToast();
  // 상태 관리
  const [dashboards, setDashboards] = useState<Dashboard[]>([]);
  const [loading, setLoading] = useState(true); // CSR이므로 초기 로딩 true
  const [error, setError] = useState<string | null>(null);
  const [searchTerm, setSearchTerm] = useState("");
  // 페이지네이션 상태
  const [currentPage, setCurrentPage] = useState(1);
  const [pageSize, setPageSize] = useState(10);
  const [totalCount, setTotalCount] = useState(0);
  // 모달 상태
  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
  const [deleteTarget, setDeleteTarget] = useState<{ id: string; title: string } | null>(null);
  // 대시보드 목록 로드
  const loadDashboards = async () => {
    try {
      setLoading(true);
      setError(null);
      const result = await dashboardApi.getMyDashboards({
        search: searchTerm,
        page: currentPage,
        limit: pageSize,
      });
      setDashboards(result.dashboards);
      setTotalCount(result.pagination.total);
    } catch (err) {
      console.error("Failed to load dashboards:", err);
      setError(
        err instanceof Error
          ? err.message
          : "대시보드 목록을 불러오는데 실패했습니다. 네트워크 연결을 확인하거나 잠시 후 다시 시도해주세요.",
      );
    } finally {
      setLoading(false);
    }
  };
  // 검색어/페이지 변경 시 fetch (초기 로딩 포함)
  useEffect(() => {
    loadDashboards();
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [searchTerm, currentPage, pageSize]);
  // 페이지네이션 정보 계산
  const paginationInfo: PaginationInfo = {
    currentPage,
    totalPages: Math.ceil(totalCount / pageSize) || 1,
    totalItems: totalCount,
    itemsPerPage: pageSize,
    startItem: totalCount === 0 ? 0 : (currentPage - 1) * pageSize + 1,
    endItem: Math.min(currentPage * pageSize, totalCount),
  };
  // 페이지 변경 핸들러
  const handlePageChange = (page: number) => {
    setCurrentPage(page);
  };
  // 페이지 크기 변경 핸들러
  const handlePageSizeChange = (size: number) => {
    setPageSize(size);
    setCurrentPage(1); // 페이지 크기 변경 시 첫 페이지로
  };
  // 대시보드 삭제 확인 모달 열기
  const handleDeleteClick = (id: string, title: string) => {
    setDeleteTarget({ id, title });
    setDeleteDialogOpen(true);
  };
  // 대시보드 삭제 실행
  const handleDeleteConfirm = async () => {
    if (!deleteTarget) return;
    try {
      await dashboardApi.deleteDashboard(deleteTarget.id);
      setDeleteDialogOpen(false);
      setDeleteTarget(null);
      toast({
        title: "성공",
        description: "대시보드가 삭제되었습니다.",
      });
      loadDashboards();
    } catch (err) {
      console.error("Failed to delete dashboard:", err);
      setDeleteDialogOpen(false);
      toast({
        title: "오류",
        description: "대시보드 삭제에 실패했습니다.",
        variant: "destructive",
      });
    }
  };
  // 대시보드 복사
  const handleCopy = async (dashboard: Dashboard) => {
    try {
      const fullDashboard = await dashboardApi.getDashboard(dashboard.id);
      await dashboardApi.createDashboard({
        title: `${fullDashboard.title} (복사본)`,
        description: fullDashboard.description,
        elements: fullDashboard.elements || [],
        isPublic: false,
        tags: fullDashboard.tags,
        category: fullDashboard.category,
        settings: fullDashboard.settings as { resolution?: string; backgroundColor?: string },
      });
      toast({
        title: "성공",
        description: "대시보드가 복사되었습니다.",
      });
      loadDashboards();
    } catch (err) {
      console.error("Failed to copy dashboard:", err);
      toast({
        title: "오류",
        description: "대시보드 복사에 실패했습니다.",
        variant: "destructive",
      });
    }
  };
  // 포맷팅 헬퍼
  const formatDate = (dateString: string) => {
    return new Date(dateString).toLocaleDateString("ko-KR", {
      year: "numeric",
      month: "2-digit",
      day: "2-digit",
    });
  };
  return (
    <div className="bg-background flex min-h-screen flex-col">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">대시보드 관리</h1>
          <p className="text-muted-foreground text-sm">대시보드를 생성하고 관리할 수 있습니다</p>
        </div>
        {/* 검색 및 액션 */}
        <div className="flex flex-col gap-4 lg:flex-row lg:items-center lg:justify-between">
          <div className="flex items-center gap-4">
            <div className="relative w-full sm:w-[300px]">
              <Search className="text-muted-foreground absolute top-1/2 left-3 h-4 w-4 -translate-y-1/2" />
              <Input
                placeholder="대시보드 검색..."
                value={searchTerm}
                onChange={(e) => setSearchTerm(e.target.value)}
                className="h-10 pl-10 text-sm"
              />
            </div>
            <div className="text-muted-foreground text-sm">
              총 <span className="text-foreground font-semibold">{totalCount.toLocaleString()}</span> 건
            </div>
          </div>
          <Button onClick={() => router.push("/admin/screenMng/dashboardList/new")} className="h-10 gap-2 text-sm font-medium">
            <Plus className="h-4 w-4" />
            새 대시보드 생성
          </Button>
        </div>
        {/* 대시보드 목록 */}
        {loading ? (
          <>
            {/* 데스크톱 테이블 스켈레톤 */}
            <div className="bg-card hidden shadow-sm lg:block">
              <Table>
                <TableHeader>
                  <TableRow className="bg-muted/50 hover:bg-muted/50 border-b">
                    <TableHead className="h-12 text-sm font-semibold">제목</TableHead>
                    <TableHead className="h-12 text-sm font-semibold">설명</TableHead>
                    <TableHead className="h-12 text-sm font-semibold">생성자</TableHead>
                    <TableHead className="h-12 text-sm font-semibold">생성일</TableHead>
                    <TableHead className="h-12 text-sm font-semibold">수정일</TableHead>
                    <TableHead className="h-12 text-right text-sm font-semibold">작업</TableHead>
                  </TableRow>
                </TableHeader>
                <TableBody>
                  {Array.from({ length: 10 }).map((_, index) => (
                    <TableRow key={index} className="border-b">
                      <TableCell className="h-16">
                        <div className="bg-muted h-4 animate-pulse rounded"></div>
                      </TableCell>
                      <TableCell className="h-16">
                        <div className="bg-muted h-4 animate-pulse rounded"></div>
                      </TableCell>
                      <TableCell className="h-16">
                        <div className="bg-muted h-4 w-20 animate-pulse rounded"></div>
                      </TableCell>
                      <TableCell className="h-16">
                        <div className="bg-muted h-4 w-24 animate-pulse rounded"></div>
                      </TableCell>
                      <TableCell className="h-16">
                        <div className="bg-muted h-4 w-24 animate-pulse rounded"></div>
                      </TableCell>
                      <TableCell className="h-16 text-right">
                        <div className="bg-muted ml-auto h-8 w-8 animate-pulse rounded"></div>
                      </TableCell>
                    </TableRow>
                  ))}
                </TableBody>
              </Table>
            </div>
            {/* 모바일/태블릿 카드 스켈레톤 */}
            <div className="grid gap-4 sm:grid-cols-2 lg:hidden">
              {Array.from({ length: 6 }).map((_, index) => (
                <div key={index} className="bg-card rounded-lg border p-4 shadow-sm">
                  <div className="mb-4 flex items-start justify-between">
                    <div className="flex-1 space-y-2">
                      <div className="bg-muted h-5 w-32 animate-pulse rounded"></div>
                      <div className="bg-muted h-4 w-24 animate-pulse rounded"></div>
                    </div>
                  </div>
                  <div className="space-y-2 border-t pt-4">
                    {Array.from({ length: 3 }).map((_, i) => (
                      <div key={i} className="flex justify-between">
                        <div className="bg-muted h-4 w-16 animate-pulse rounded"></div>
                        <div className="bg-muted h-4 w-32 animate-pulse rounded"></div>
                      </div>
                    ))}
                  </div>
                </div>
              ))}
            </div>
          </>
        ) : error ? (
          <div className="border-destructive/50 bg-destructive/10 flex flex-col items-center justify-center rounded-lg border p-12">
            <div className="flex flex-col items-center gap-4 text-center">
              <div className="bg-destructive/20 flex h-16 w-16 items-center justify-center rounded-full">
                <AlertCircle className="text-destructive h-8 w-8" />
              </div>
              <div>
                <h3 className="text-destructive mb-2 text-lg font-semibold">데이터를 불러올 수 없습니다</h3>
                <p className="text-destructive/80 max-w-md text-sm">{error}</p>
              </div>
              <Button onClick={loadDashboards} variant="outline" className="mt-2 gap-2">
                <RefreshCw className="h-4 w-4" />
                다시 시도
              </Button>
            </div>
          </div>
        ) : dashboards.length === 0 ? (
          <div className="bg-card flex h-64 flex-col items-center justify-center shadow-sm">
            <div className="flex flex-col items-center gap-2 text-center">
              <p className="text-muted-foreground text-sm">대시보드가 없습니다</p>
            </div>
          </div>
        ) : (
          <>
            {/* 데스크톱 테이블 뷰 (lg 이상) */}
            <div className="bg-card hidden shadow-sm lg:block">
              <Table>
                <TableHeader>
                  <TableRow className="bg-muted/50 hover:bg-muted/50 border-b">
                    <TableHead className="h-12 text-sm font-semibold">제목</TableHead>
                    <TableHead className="h-12 text-sm font-semibold">설명</TableHead>
                    <TableHead className="h-12 text-sm font-semibold">생성자</TableHead>
                    <TableHead className="h-12 text-sm font-semibold">생성일</TableHead>
                    <TableHead className="h-12 text-sm font-semibold">수정일</TableHead>
                    <TableHead className="h-12 text-right text-sm font-semibold">작업</TableHead>
                  </TableRow>
                </TableHeader>
                <TableBody>
                  {dashboards.map((dashboard) => (
                    <TableRow key={dashboard.id} className="hover:bg-muted/50 border-b transition-colors">
                      <TableCell className="h-16 text-sm font-medium">
                      <button
                        onClick={() => router.push(`/admin/screenMng/dashboardList/${dashboard.id}`)}
                        className="hover:text-primary cursor-pointer text-left transition-colors hover:underline"
                      >
                        {dashboard.title}
                      </button>
                      </TableCell>
                      <TableCell className="text-muted-foreground h-16 max-w-md truncate text-sm">
                        {dashboard.description || "-"}
                      </TableCell>
                      <TableCell className="text-muted-foreground h-16 text-sm">
                        {dashboard.createdByName || dashboard.createdBy || "-"}
                      </TableCell>
                      <TableCell className="text-muted-foreground h-16 text-sm">
                        {formatDate(dashboard.createdAt)}
                      </TableCell>
                      <TableCell className="text-muted-foreground h-16 text-sm">
                        {formatDate(dashboard.updatedAt)}
                      </TableCell>
                      <TableCell className="h-16 text-right">
                        <DropdownMenu>
                          <DropdownMenuTrigger asChild>
                            <Button variant="ghost" size="icon" className="h-8 w-8">
                              <MoreVertical className="h-4 w-4" />
                            </Button>
                          </DropdownMenuTrigger>
                          <DropdownMenuContent align="end">
                            <DropdownMenuItem
                              onClick={() => router.push(`/admin/screenMng/dashboardList/${dashboard.id}`)}
                              className="gap-2 text-sm"
                            >
                              <Edit className="h-4 w-4" />
                              편집
                            </DropdownMenuItem>
                            <DropdownMenuItem onClick={() => handleCopy(dashboard)} className="gap-2 text-sm">
                              <Copy className="h-4 w-4" />
                              복사
                            </DropdownMenuItem>
                            <DropdownMenuItem
                              onClick={() => handleDeleteClick(dashboard.id, dashboard.title)}
                              className="text-destructive focus:text-destructive gap-2 text-sm"
                            >
                              <Trash2 className="h-4 w-4" />
                              삭제
                            </DropdownMenuItem>
                          </DropdownMenuContent>
                        </DropdownMenu>
                      </TableCell>
                    </TableRow>
                  ))}
                </TableBody>
              </Table>
            </div>
            {/* 모바일/태블릿 카드 뷰 (lg 미만) */}
            <div className="grid gap-4 sm:grid-cols-2 lg:hidden">
              {dashboards.map((dashboard) => (
                <div
                  key={dashboard.id}
                  className="bg-card hover:bg-muted/50 rounded-lg border p-4 shadow-sm transition-colors"
                >
                  {/* 헤더 */}
                  <div className="mb-4 flex items-start justify-between">
                    <div className="flex-1">
                      <button
                        onClick={() => router.push(`/admin/screenMng/dashboardList/${dashboard.id}`)}
                        className="hover:text-primary cursor-pointer text-left transition-colors hover:underline"
                      >
                        <h3 className="text-base font-semibold">{dashboard.title}</h3>
                      </button>
                      <p className="text-muted-foreground mt-1 text-sm">{dashboard.id}</p>
                    </div>
                  </div>
                  {/* 정보 */}
                  <div className="space-y-2 border-t pt-4">
                    <div className="flex justify-between text-sm">
                      <span className="text-muted-foreground">설명</span>
                      <span className="max-w-[200px] truncate font-medium">{dashboard.description || "-"}</span>
                    </div>
                    <div className="flex justify-between text-sm">
                      <span className="text-muted-foreground">생성자</span>
                      <span className="font-medium">{dashboard.createdByName || dashboard.createdBy || "-"}</span>
                    </div>
                    <div className="flex justify-between text-sm">
                      <span className="text-muted-foreground">생성일</span>
                      <span className="font-medium">{formatDate(dashboard.createdAt)}</span>
                    </div>
                    <div className="flex justify-between text-sm">
                      <span className="text-muted-foreground">수정일</span>
                      <span className="font-medium">{formatDate(dashboard.updatedAt)}</span>
                    </div>
                  </div>
                  {/* 액션 */}
                  <div className="mt-4 flex gap-2 border-t pt-4">
                    <Button
                      variant="outline"
                      size="sm"
                      className="h-9 flex-1 gap-2 text-sm"
                      onClick={() => router.push(`/admin/screenMng/dashboardList/${dashboard.id}`)}
                    >
                      <Edit className="h-4 w-4" />
                      편집
                    </Button>
                    <Button
                      variant="outline"
                      size="sm"
                      className="h-9 flex-1 gap-2 text-sm"
                      onClick={() => handleCopy(dashboard)}
                    >
                      <Copy className="h-4 w-4" />
                      복사
                    </Button>
                    <Button
                      variant="outline"
                      size="sm"
                      className="text-destructive hover:bg-destructive/10 hover:text-destructive h-9 gap-2 text-sm"
                      onClick={() => handleDeleteClick(dashboard.id, dashboard.title)}
                    >
                      <Trash2 className="h-4 w-4" />
                    </Button>
                  </div>
                </div>
              ))}
            </div>
          </>
        )}
        {/* 페이지네이션 */}
        {!loading && dashboards.length > 0 && (
          <Pagination
            paginationInfo={paginationInfo}
            onPageChange={handlePageChange}
            onPageSizeChange={handlePageSizeChange}
            showPageSizeSelector={true}
            pageSizeOptions={[10, 20, 50, 100]}
          />
        )}
        {/* 삭제 확인 모달 */}
        <DeleteConfirmModal
          open={deleteDialogOpen}
          onOpenChange={setDeleteDialogOpen}
          title="대시보드 삭제"
          description={
            <>
              &quot;{deleteTarget?.title}&quot; 대시보드를 삭제하시겠습니까?
              <br />이 작업은 되돌릴 수 없습니다.
            </>
          }
          onConfirm={handleDeleteConfirm}
        />
      </div>
    </div>
  );
 }
--- a/frontend/app/(main)/admin/screenMng/page.tsx
+++ b/frontend/app/(main)/admin/screenMng/page.tsx
@ -0,0 +1,129 @@
 "use client";
 import { useState } from "react";
 import { Button } from "@/components/ui/button";
 import { ArrowLeft } from "lucide-react";
 import ScreenList from "@/components/screen/ScreenList";
 import ScreenDesigner from "@/components/screen/ScreenDesigner";
 import TemplateManager from "@/components/screen/TemplateManager";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 import { ScreenDefinition } from "@/types/screen";
 // 단계별 진행을 위한 타입 정의
 type Step = "list" | "design" | "template";
 export default function ScreenManagementPage() {
  const [currentStep, setCurrentStep] = useState<Step>("list");
  const [selectedScreen, setSelectedScreen] = useState<ScreenDefinition | null>(null);
  const [stepHistory, setStepHistory] = useState<Step[]>(["list"]);
  // 화면 설계 모드일 때는 전체 화면 사용
  const isDesignMode = currentStep === "design";
  // 단계별 제목과 설명
  const stepConfig = {
    list: {
      title: "화면 목록 관리",
      description: "생성된 화면들을 확인하고 관리하세요",
    },
    design: {
      title: "화면 설계",
      description: "드래그앤드롭으로 화면을 설계하세요",
    },
    template: {
      title: "템플릿 관리",
      description: "화면 템플릿을 관리하고 재사용하세요",
    },
  };
  // 다음 단계로 이동
  const goToNextStep = (nextStep: Step) => {
    setStepHistory((prev) => [...prev, nextStep]);
    setCurrentStep(nextStep);
  };
  // 이전 단계로 이동
  const goToPreviousStep = () => {
    if (stepHistory.length > 1) {
      const newHistory = stepHistory.slice(0, -1);
      const previousStep = newHistory[newHistory.length - 1];
      setStepHistory(newHistory);
      setCurrentStep(previousStep);
    }
  };
  // 특정 단계로 이동
  const goToStep = (step: Step) => {
    setCurrentStep(step);
    // 해당 단계까지의 히스토리만 유지
    const stepIndex = stepHistory.findIndex((s) => s === step);
    if (stepIndex !== -1) {
      setStepHistory(stepHistory.slice(0, stepIndex + 1));
    }
  };
  // 화면 설계 모드일 때는 레이아웃 없이 전체 화면 사용 (고정 높이)
  if (isDesignMode) {
    return (
      <div className="fixed inset-0 z-50 bg-background">
        <ScreenDesigner selectedScreen={selectedScreen} onBackToList={() => goToStep("list")} />
      </div>
    );
  }
  return (
    <div className="flex min-h-screen flex-col bg-background">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">화면 관리</h1>
          <p className="text-sm text-muted-foreground">화면을 설계하고 템플릿을 관리합니다</p>
        </div>
        {/* 단계별 내용 */}
        <div className="flex-1">
          {/* 화면 목록 단계 */}
          {currentStep === "list" && (
            <ScreenList
              onScreenSelect={setSelectedScreen}
              selectedScreen={selectedScreen}
              onDesignScreen={(screen) => {
                setSelectedScreen(screen);
                goToNextStep("design");
              }}
            />
          )}
          {/* 템플릿 관리 단계 */}
          {currentStep === "template" && (
            <div className="space-y-6">
              <div className="flex items-center justify-between rounded-lg border bg-card p-4 shadow-sm">
                <h2 className="text-xl font-semibold">{stepConfig.template.title}</h2>
                <div className="flex gap-2">
                  <Button 
                    variant="outline" 
                    onClick={goToPreviousStep}
                    className="h-10 gap-2 text-sm font-medium"
                  >
                    <ArrowLeft className="h-4 w-4" />
                    이전 단계
                  </Button>
                  <Button 
                    onClick={() => goToStep("list")}
                    className="h-10 gap-2 text-sm font-medium"
                  >
                    목록으로 돌아가기
                  </Button>
                </div>
              </div>
              <TemplateManager selectedScreen={selectedScreen} onBackToList={() => goToStep("list")} />
            </div>
          )}
        </div>
      </div>
      {/* Scroll to Top 버튼 */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/screenMng/screenMngList/page.tsx
+++ b/frontend/app/(main)/admin/screenMng/screenMngList/page.tsx
@ -1,249 +0,0 @@
 "use client";
 import { useState, useEffect, useCallback } from "react";
 import { useSearchParams } from "next/navigation";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { ArrowLeft, Plus, RefreshCw, Search, LayoutGrid, LayoutList } from "lucide-react";
 import ScreenList from "@/components/screen/ScreenList";
 import ScreenDesigner from "@/components/screen/ScreenDesigner";
 import TemplateManager from "@/components/screen/TemplateManager";
 import { ScreenGroupTreeView } from "@/components/screen/ScreenGroupTreeView";
 import { ScreenRelationFlow } from "@/components/screen/ScreenRelationFlow";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 import { ScreenDefinition } from "@/types/screen";
 import { screenApi } from "@/lib/api/screen";
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import CreateScreenModal from "@/components/screen/CreateScreenModal";
 // 단계별 진행을 위한 타입 정의
 type Step = "list" | "design" | "template";
 type ViewMode = "tree" | "table";
 export default function ScreenManagementPage() {
  const searchParams = useSearchParams();
  const [currentStep, setCurrentStep] = useState<Step>("list");
  const [selectedScreen, setSelectedScreen] = useState<ScreenDefinition | null>(null);
  const [selectedGroup, setSelectedGroup] = useState<{ id: number; name: string; company_code?: string } | null>(null);
  const [focusedScreenIdInGroup, setFocusedScreenIdInGroup] = useState<number | null>(null);
  const [stepHistory, setStepHistory] = useState<Step[]>(["list"]);
  const [viewMode, setViewMode] = useState<ViewMode>("tree");
  const [screens, setScreens] = useState<ScreenDefinition[]>([]);
  const [loading, setLoading] = useState(true);
  const [searchTerm, setSearchTerm] = useState("");
  const [isCreateOpen, setIsCreateOpen] = useState(false);
  // 화면 목록 로드
  const loadScreens = useCallback(async () => {
    try {
      setLoading(true);
      const result = await screenApi.getScreens({ page: 1, size: 1000, searchTerm: "" });
      // screenApi.getScreens는 { data: ScreenDefinition[], total, page, size, totalPages } 형태 반환
      if (result.data && result.data.length > 0) {
        setScreens(result.data);
      }
    } catch (error) {
      console.error("화면 목록 로드 실패:", error);
    } finally {
      setLoading(false);
    }
  }, []);
  useEffect(() => {
    loadScreens();
  }, [loadScreens]);
  // 화면 목록 새로고침 이벤트 리스너
  useEffect(() => {
    const handleScreenListRefresh = () => {
      console.log("🔄 화면 목록 새로고침 이벤트 수신");
      loadScreens();
    };
    window.addEventListener("screen-list-refresh", handleScreenListRefresh);
    return () => {
      window.removeEventListener("screen-list-refresh", handleScreenListRefresh);
    };
  }, [loadScreens]);
  // URL 쿼리 파라미터로 화면 디자이너 자동 열기
  useEffect(() => {
    const openDesignerId = searchParams.get("openDesigner");
    if (openDesignerId && screens.length > 0) {
      const screenId = parseInt(openDesignerId, 10);
      const targetScreen = screens.find((s) => s.screenId === screenId);
      if (targetScreen) {
        setSelectedScreen(targetScreen);
        setCurrentStep("design");
        setStepHistory(["list", "design"]);
      }
    }
  }, [searchParams, screens]);
  // 화면 설계 모드일 때는 전체 화면 사용
  const isDesignMode = currentStep === "design";
  // 다음 단계로 이동
  const goToNextStep = (nextStep: Step) => {
    setStepHistory((prev) => [...prev, nextStep]);
    setCurrentStep(nextStep);
  };
  // 특정 단계로 이동
  const goToStep = (step: Step) => {
    setCurrentStep(step);
    const stepIndex = stepHistory.findIndex((s) => s === step);
    if (stepIndex !== -1) {
      setStepHistory(stepHistory.slice(0, stepIndex + 1));
    }
  };
  // 화면 선택 핸들러 (개별 화면 선택 시 그룹 선택 해제)
  const handleScreenSelect = (screen: ScreenDefinition) => {
    setSelectedScreen(screen);
    setSelectedGroup(null); // 그룹 선택 해제
  };
  // 화면 디자인 핸들러
  const handleDesignScreen = (screen: ScreenDefinition) => {
    setSelectedScreen(screen);
    goToNextStep("design");
  };
  // 검색어로 필터링된 화면
  // 검색어가 여러 키워드(폴더 계층 검색)이면 화면 필터링 없이 모든 화면 표시
  // 단일 키워드면 해당 키워드로 화면 필터링
  const searchKeywords = searchTerm.toLowerCase().trim().split(/\s+/).filter(Boolean);
  const filteredScreens = searchKeywords.length > 1 
    ? screens  // 폴더 계층 검색 시에는 화면 필터링 없음 (폴더에서 이미 필터링됨)
    : screens.filter((screen) =>
      screen.screenName.toLowerCase().includes(searchTerm.toLowerCase()) ||
      screen.screenCode.toLowerCase().includes(searchTerm.toLowerCase())
    );
  // 화면 설계 모드일 때는 레이아웃 없이 전체 화면 사용
  if (isDesignMode) {
    return (
      <div className="fixed inset-0 z-50 bg-background">
        <ScreenDesigner selectedScreen={selectedScreen} onBackToList={() => goToStep("list")} />
      </div>
    );
  }
  return (
    <div className="flex h-screen flex-col bg-background overflow-hidden">
      {/* 페이지 헤더 */}
      <div className="flex-shrink-0 border-b bg-background px-6 py-4">
        <div className="flex items-center justify-between">
          <div>
            <h1 className="text-2xl font-bold tracking-tight">화면 관리</h1>
            <p className="text-sm text-muted-foreground">화면을 그룹별로 관리하고 데이터 관계를 확인합니다</p>
          </div>
          <div className="flex items-center gap-2">
            {/* 뷰 모드 전환 */}
            <Tabs value={viewMode} onValueChange={(v) => setViewMode(v as ViewMode)}>
              <TabsList className="h-9">
                <TabsTrigger value="tree" className="gap-1.5 px-3">
                  <LayoutGrid className="h-4 w-4" />
                  트리
                </TabsTrigger>
                <TabsTrigger value="table" className="gap-1.5 px-3">
                  <LayoutList className="h-4 w-4" />
                  테이블
                </TabsTrigger>
              </TabsList>
            </Tabs>
            <Button variant="outline" size="icon" onClick={loadScreens}>
              <RefreshCw className="h-4 w-4" />
            </Button>
            <Button onClick={() => setIsCreateOpen(true)} className="gap-2">
              <Plus className="h-4 w-4" />
              새 화면
            </Button>
          </div>
        </div>
      </div>
      {/* 메인 콘텐츠 */}
      {viewMode === "tree" ? (
        <div className="flex-1 overflow-hidden flex">
          {/* 왼쪽: 트리 구조 */}
          <div className="w-[350px] min-w-[280px] max-w-[450px] flex flex-col border-r bg-background">
            {/* 검색 */}
            <div className="flex-shrink-0 p-3 border-b">
              <div className="relative">
                <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
                <Input
                  placeholder="화면 검색..."
                  value={searchTerm}
                  onChange={(e) => setSearchTerm(e.target.value)}
                  className="pl-9 h-9"
                />
              </div>
            </div>
            {/* 트리 뷰 */}
            <div className="flex-1 overflow-hidden">
              <ScreenGroupTreeView
                screens={filteredScreens}
                selectedScreen={selectedScreen}
                onScreenSelect={handleScreenSelect}
                onScreenDesign={handleDesignScreen}
                searchTerm={searchTerm}
                onGroupSelect={(group) => {
                  setSelectedGroup(group);
                  setSelectedScreen(null); // 화면 선택 해제
                  setFocusedScreenIdInGroup(null); // 포커스 초기화
                }}
                onScreenSelectInGroup={(group, screenId) => {
                  // 그룹 내 화면 클릭 시
                  const isNewGroup = selectedGroup?.id !== group.id;
                  if (isNewGroup) {
                    // 새 그룹 진입: 포커싱 없이 시작 (첫 진입 시 망가지는 문제 방지)
                    setSelectedGroup(group);
                    setFocusedScreenIdInGroup(null);
                  } else {
                    // 같은 그룹 내에서 다른 화면 클릭: 포커싱 유지
                    setFocusedScreenIdInGroup(screenId);
                  }
                  setSelectedScreen(null);
                }}
              />
            </div>
          </div>
          {/* 오른쪽: 관계 시각화 (React Flow) */}
          <div className="flex-1 overflow-hidden">
            <ScreenRelationFlow 
              screen={selectedScreen} 
              selectedGroup={selectedGroup}
              initialFocusedScreenId={focusedScreenIdInGroup}
            />
          </div>
        </div>
      ) : (
        // 테이블 뷰 (기존 ScreenList 사용)
        <div className="flex-1 overflow-auto p-6">
          <ScreenList
            onScreenSelect={handleScreenSelect}
            selectedScreen={selectedScreen}
            onDesignScreen={handleDesignScreen}
          />
        </div>
      )}
      {/* 화면 생성 모달 */}
      <CreateScreenModal
        isOpen={isCreateOpen}
        onClose={() => setIsCreateOpen(false)}
        onSuccess={() => {
          setIsCreateOpen(false);
          loadScreens();
        }}
      />
      {/* Scroll to Top 버튼 */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/systemMng/tableMngList/page.tsx
+++ b/frontend/app/(main)/admin/systemMng/tableMngList/page.tsx
@ -6,10 +6,7 @@ import { Button } from "@/components/ui/button";
 import { Badge } from "@/components/ui/badge";
 import { Checkbox } from "@/components/ui/checkbox";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
-import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Search, Database, RefreshCw, Settings, Plus, Activity, Trash2, Copy } from "lucide-react";
 import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from "@/components/ui/command";
 import { Search, Database, RefreshCw, Settings, Plus, Activity, Trash2, Copy, Check, ChevronsUpDown } from "lucide-react";
 import { cn } from "@/lib/utils";
 import { LoadingSpinner } from "@/components/common/LoadingSpinner";
 import { toast } from "sonner";
 import { useMultiLang } from "@/hooks/useMultiLang";
@ -93,13 +90,6 @@ export default function TableManagementPage() {
  // 🎯 Entity 조인 관련 상태
  const [referenceTableColumns, setReferenceTableColumns] = useState<Record<string, ReferenceTableColumn[]>>({});
  // 🆕 Entity 타입 Combobox 열림/닫힘 상태 (컬럼별 관리)
  const [entityComboboxOpen, setEntityComboboxOpen] = useState<Record<string, {
    table: boolean;
    joinColumn: boolean;
    displayColumn: boolean;
  }>>({});
  // DDL 기능 관련 상태
  const [createTableModalOpen, setCreateTableModalOpen] = useState(false);
  const [addColumnModalOpen, setAddColumnModalOpen] = useState(false);
@ -1398,266 +1388,113 @@ export default function TableManagementPage() {
                                {/* 입력 타입이 'entity'인 경우 참조 테이블 선택 */}
                                {column.inputType === "entity" && (
                                  <>
-                                    {/* 참조 테이블 - 검색 가능한 Combobox */}
+                                    {/* 참조 테이블 */}
-                                    <div className="w-56">
+                                    <div className="w-48">
                                      <label className="text-muted-foreground mb-1 block text-xs">참조 테이블</label>
-                                      <Popover
+                                      <Select
-                                        open={entityComboboxOpen[column.columnName]?.table || false}
+                                        value={column.referenceTable || "none"}
-                                        onOpenChange={(open) =>
+                                        onValueChange={(value) =>
-                                          setEntityComboboxOpen((prev) => ({
+                                          handleDetailSettingsChange(column.columnName, "entity", value)
                                            ...prev,
                                            [column.columnName]: { ...prev[column.columnName], table: open },
                                          }))
                                        }
                                      >
-                                        <PopoverTrigger asChild>
+                                        <SelectTrigger className="bg-background h-8 w-full text-xs">
-                                          <Button
+                                          <SelectValue placeholder="선택" />
-                                            variant="outline"
+                                        </SelectTrigger>
-                                            role="combobox"
+                                        <SelectContent>
-                                            aria-expanded={entityComboboxOpen[column.columnName]?.table || false}
+                                          {referenceTableOptions.map((option, index) => (
-                                            className="bg-background h-8 w-full justify-between text-xs"
+                                            <SelectItem key={`entity-${option.value}-${index}`} value={option.value}>
                                          >
                                            {column.referenceTable && column.referenceTable !== "none"
                                              ? referenceTableOptions.find((opt) => opt.value === column.referenceTable)?.label ||
                                                column.referenceTable
                                              : "테이블 선택..."}
                                            <ChevronsUpDown className="ml-2 h-3 w-3 shrink-0 opacity-50" />
                                          </Button>
                                        </PopoverTrigger>
                                        <PopoverContent className="w-[280px] p-0" align="start">
                                          <Command>
                                            <CommandInput placeholder="테이블 검색..." className="h-8 text-xs" />
                                            <CommandList className="max-h-[200px]">
                                              <CommandEmpty className="py-2 text-center text-xs">
                                                테이블을 찾을 수 없습니다.
                                              </CommandEmpty>
                                              <CommandGroup>
                                                {referenceTableOptions.map((option) => (
                                                  <CommandItem
                                                    key={option.value}
                                                    value={`${option.label} ${option.value}`}
                                                    onSelect={() => {
                                                      handleDetailSettingsChange(column.columnName, "entity", option.value);
                                                      setEntityComboboxOpen((prev) => ({
                                                        ...prev,
                                                        [column.columnName]: { ...prev[column.columnName], table: false },
                                                      }));
                                                    }}
                                                    className="text-xs"
                                                  >
                                                    <Check
                                                      className={cn(
                                                        "mr-2 h-3 w-3",
                                                        column.referenceTable === option.value ? "opacity-100" : "opacity-0",
                                                      )}
                                                    />
                                              <div className="flex flex-col">
                                                <span className="font-medium">{option.label}</span>
-                                                      {option.value !== "none" && (
+                                                <span className="text-muted-foreground text-xs">{option.value}</span>
                                                        <span className="text-muted-foreground text-[10px]">{option.value}</span>
                                                      )}
                                              </div>
-                                                  </CommandItem>
+                                            </SelectItem>
                                          ))}
-                                              </CommandGroup>
+                                        </SelectContent>
-                                            </CommandList>
+                                      </Select>
                                          </Command>
                                        </PopoverContent>
                                      </Popover>
                                    </div>
-                                    {/* 조인 컬럼 - 검색 가능한 Combobox */}
+                                    {/* 조인 컬럼 */}
                                    {column.referenceTable && column.referenceTable !== "none" && (
-                                      <div className="w-56">
+                                      <div className="w-48">
                                        <label className="text-muted-foreground mb-1 block text-xs">조인 컬럼</label>
-                                        <Popover
+                                        <Select
-                                          open={entityComboboxOpen[column.columnName]?.joinColumn || false}
+                                          value={column.referenceColumn || "none"}
-                                          onOpenChange={(open) =>
+                                          onValueChange={(value) =>
-                                            setEntityComboboxOpen((prev) => ({
+                                            handleDetailSettingsChange(
-                                              ...prev,
+                                              column.columnName,
-                                              [column.columnName]: { ...prev[column.columnName], joinColumn: open },
+                                              "entity_reference_column",
-                                            }))
+                                              value,
                                            )
                                          }
                                        >
-                                          <PopoverTrigger asChild>
+                                          <SelectTrigger className="bg-background h-8 w-full text-xs">
-                                            <Button
+                                            <SelectValue placeholder="선택" />
-                                              variant="outline"
+                                          </SelectTrigger>
-                                              role="combobox"
+                                          <SelectContent>
-                                              aria-expanded={entityComboboxOpen[column.columnName]?.joinColumn || false}
+                                            <SelectItem value="none">-- 선택 안함 --</SelectItem>
-                                              className="bg-background h-8 w-full justify-between text-xs"
+                                            {referenceTableColumns[column.referenceTable]?.map((refCol, index) => (
-                                              disabled={!referenceTableColumns[column.referenceTable] || referenceTableColumns[column.referenceTable].length === 0}
+                                              <SelectItem
                                                key={`ref-col-${refCol.columnName}-${index}`}
                                                value={refCol.columnName}
                                              >
                                              {!referenceTableColumns[column.referenceTable] || referenceTableColumns[column.referenceTable].length === 0 ? (
                                                <span className="flex items-center gap-2">
                                                  <div className="border-primary h-3 w-3 animate-spin rounded-full border border-t-transparent"></div>
                                                  로딩중...
                                                </span>
                                              ) : column.referenceColumn && column.referenceColumn !== "none" ? (
                                                column.referenceColumn
                                              ) : (
                                                "컬럼 선택..."
                                              )}
                                              <ChevronsUpDown className="ml-2 h-3 w-3 shrink-0 opacity-50" />
                                            </Button>
                                          </PopoverTrigger>
                                          <PopoverContent className="w-[280px] p-0" align="start">
                                            <Command>
                                              <CommandInput placeholder="컬럼 검색..." className="h-8 text-xs" />
                                              <CommandList className="max-h-[200px]">
                                                <CommandEmpty className="py-2 text-center text-xs">
                                                  컬럼을 찾을 수 없습니다.
                                                </CommandEmpty>
                                                <CommandGroup>
                                                  <CommandItem
                                                    value="none"
                                                    onSelect={() => {
                                                      handleDetailSettingsChange(column.columnName, "entity_reference_column", "none");
                                                      setEntityComboboxOpen((prev) => ({
                                                        ...prev,
                                                        [column.columnName]: { ...prev[column.columnName], joinColumn: false },
                                                      }));
                                                    }}
                                                    className="text-xs"
                                                  >
                                                    <Check
                                                      className={cn(
                                                        "mr-2 h-3 w-3",
                                                        column.referenceColumn === "none" || !column.referenceColumn ? "opacity-100" : "opacity-0",
                                                      )}
                                                    />
                                                    -- 선택 안함 --
                                                  </CommandItem>
                                                  {referenceTableColumns[column.referenceTable]?.map((refCol) => (
                                                    <CommandItem
                                                      key={refCol.columnName}
                                                      value={`${refCol.columnLabel || ""} ${refCol.columnName}`}
                                                      onSelect={() => {
                                                        handleDetailSettingsChange(column.columnName, "entity_reference_column", refCol.columnName);
                                                        setEntityComboboxOpen((prev) => ({
                                                          ...prev,
                                                          [column.columnName]: { ...prev[column.columnName], joinColumn: false },
                                                        }));
                                                      }}
                                                      className="text-xs"
                                                    >
                                                      <Check
                                                        className={cn(
                                                          "mr-2 h-3 w-3",
                                                          column.referenceColumn === refCol.columnName ? "opacity-100" : "opacity-0",
                                                        )}
                                                      />
                                                      <div className="flex flex-col">
                                                <span className="font-medium">{refCol.columnName}</span>
-                                                        {refCol.columnLabel && (
+                                              </SelectItem>
                                                          <span className="text-muted-foreground text-[10px]">{refCol.columnLabel}</span>
                                                        )}
                                                      </div>
                                                    </CommandItem>
                                            ))}
-                                                </CommandGroup>
+                                            {(!referenceTableColumns[column.referenceTable] ||
-                                              </CommandList>
+                                              referenceTableColumns[column.referenceTable].length === 0) && (
-                                            </Command>
+                                              <SelectItem value="loading" disabled>
-                                          </PopoverContent>
+                                                <div className="flex items-center gap-2">
-                                        </Popover>
+                                                  <div className="border-primary h-3 w-3 animate-spin rounded-full border border-t-transparent"></div>
                                                  로딩중
                                                </div>
                                              </SelectItem>
                                            )}
                                          </SelectContent>
                                        </Select>
                                      </div>
                                    )}
-                                    {/* 표시 컬럼 - 검색 가능한 Combobox */}
+                                    {/* 표시 컬럼 */}
                                    {column.referenceTable &&
                                      column.referenceTable !== "none" &&
                                      column.referenceColumn &&
                                      column.referenceColumn !== "none" && (
-                                        <div className="w-56">
+                                        <div className="w-48">
                                          <label className="text-muted-foreground mb-1 block text-xs">표시 컬럼</label>
-                                          <Popover
+                                          <Select
-                                            open={entityComboboxOpen[column.columnName]?.displayColumn || false}
+                                            value={column.displayColumn || "none"}
-                                            onOpenChange={(open) =>
+                                            onValueChange={(value) =>
-                                              setEntityComboboxOpen((prev) => ({
+                                              handleDetailSettingsChange(
-                                                ...prev,
+                                                column.columnName,
-                                                [column.columnName]: { ...prev[column.columnName], displayColumn: open },
+                                                "entity_display_column",
-                                              }))
+                                                value,
                                              )
                                            }
                                          >
-                                            <PopoverTrigger asChild>
+                                            <SelectTrigger className="bg-background h-8 w-full text-xs">
-                                              <Button
+                                              <SelectValue placeholder="선택" />
-                                                variant="outline"
+                                            </SelectTrigger>
-                                                role="combobox"
+                                            <SelectContent>
-                                                aria-expanded={entityComboboxOpen[column.columnName]?.displayColumn || false}
+                                              <SelectItem value="none">-- 선택 안함 --</SelectItem>
-                                                className="bg-background h-8 w-full justify-between text-xs"
+                                              {referenceTableColumns[column.referenceTable]?.map((refCol, index) => (
-                                                disabled={!referenceTableColumns[column.referenceTable] || referenceTableColumns[column.referenceTable].length === 0}
+                                                <SelectItem
                                                  key={`ref-col-${refCol.columnName}-${index}`}
                                                  value={refCol.columnName}
                                                >
                                                {!referenceTableColumns[column.referenceTable] || referenceTableColumns[column.referenceTable].length === 0 ? (
                                                  <span className="flex items-center gap-2">
                                                    <div className="border-primary h-3 w-3 animate-spin rounded-full border border-t-transparent"></div>
                                                    로딩중...
                                                  </span>
                                                ) : column.displayColumn && column.displayColumn !== "none" ? (
                                                  column.displayColumn
                                                ) : (
                                                  "컬럼 선택..."
                                                )}
                                                <ChevronsUpDown className="ml-2 h-3 w-3 shrink-0 opacity-50" />
                                              </Button>
                                            </PopoverTrigger>
                                            <PopoverContent className="w-[280px] p-0" align="start">
                                              <Command>
                                                <CommandInput placeholder="컬럼 검색..." className="h-8 text-xs" />
                                                <CommandList className="max-h-[200px]">
                                                  <CommandEmpty className="py-2 text-center text-xs">
                                                    컬럼을 찾을 수 없습니다.
                                                  </CommandEmpty>
                                                  <CommandGroup>
                                                    <CommandItem
                                                      value="none"
                                                      onSelect={() => {
                                                        handleDetailSettingsChange(column.columnName, "entity_display_column", "none");
                                                        setEntityComboboxOpen((prev) => ({
                                                          ...prev,
                                                          [column.columnName]: { ...prev[column.columnName], displayColumn: false },
                                                        }));
                                                      }}
                                                      className="text-xs"
                                                    >
                                                      <Check
                                                        className={cn(
                                                          "mr-2 h-3 w-3",
                                                          column.displayColumn === "none" || !column.displayColumn ? "opacity-100" : "opacity-0",
                                                        )}
                                                      />
                                                      -- 선택 안함 --
                                                    </CommandItem>
                                                    {referenceTableColumns[column.referenceTable]?.map((refCol) => (
                                                      <CommandItem
                                                        key={refCol.columnName}
                                                        value={`${refCol.columnLabel || ""} ${refCol.columnName}`}
                                                        onSelect={() => {
                                                          handleDetailSettingsChange(column.columnName, "entity_display_column", refCol.columnName);
                                                          setEntityComboboxOpen((prev) => ({
                                                            ...prev,
                                                            [column.columnName]: { ...prev[column.columnName], displayColumn: false },
                                                          }));
                                                        }}
                                                        className="text-xs"
                                                      >
                                                        <Check
                                                          className={cn(
                                                            "mr-2 h-3 w-3",
                                                            column.displayColumn === refCol.columnName ? "opacity-100" : "opacity-0",
                                                          )}
                                                        />
                                                        <div className="flex flex-col">
                                                  <span className="font-medium">{refCol.columnName}</span>
-                                                          {refCol.columnLabel && (
+                                                </SelectItem>
                                                            <span className="text-muted-foreground text-[10px]">{refCol.columnLabel}</span>
                                                          )}
                                                        </div>
                                                      </CommandItem>
                                              ))}
-                                                  </CommandGroup>
+                                              {(!referenceTableColumns[column.referenceTable] ||
-                                                </CommandList>
+                                                referenceTableColumns[column.referenceTable].length === 0) && (
-                                              </Command>
+                                                <SelectItem value="loading" disabled>
-                                            </PopoverContent>
+                                                  <div className="flex items-center gap-2">
-                                          </Popover>
+                                                    <div className="border-primary h-3 w-3 animate-spin rounded-full border border-t-transparent"></div>
                                                    로딩중
                                                  </div>
                                                </SelectItem>
                                              )}
                                            </SelectContent>
                                          </Select>
                                        </div>
                                      )}
@ -1668,8 +1505,8 @@ export default function TableManagementPage() {
                                      column.referenceColumn !== "none" &&
                                      column.displayColumn &&
                                      column.displayColumn !== "none" && (
-                                        <div className="bg-primary/10 text-primary flex items-center gap-1 rounded px-2 py-1 text-xs">
+                                        <div className="bg-primary/10 text-primary flex w-48 items-center gap-1 rounded px-2 py-1 text-xs">
-                                          <Check className="h-3 w-3" />
+                                          <span>✓</span>
                                          <span className="truncate">설정 완료</span>
                                        </div>
                                      )}
--- a/frontend/app/(main)/admin/userAuth/page.tsx
+++ b/frontend/app/(main)/admin/userAuth/page.tsx
@ -0,0 +1,31 @@
 "use client";
 import { UserAuthManagement } from "@/components/admin/UserAuthManagement";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 사용자 권한 관리 페이지
 * URL: /admin/userAuth
 *
 * 최고 관리자만 접근 가능
 * 사용자별 권한 레벨(SUPER_ADMIN, COMPANY_ADMIN, USER 등) 관리
 */
 export default function UserAuthPage() {
  return (
    <div className="bg-background flex min-h-screen flex-col">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">사용자 권한 관리</h1>
          <p className="text-muted-foreground text-sm">사용자별 권한 레벨을 관리합니다. (최고 관리자 전용)</p>
        </div>
        {/* 메인 컨텐츠 */}
        <UserAuthManagement />
      </div>
      {/* Scroll to Top 버튼 (모바일/태블릿 전용) */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/userMng/companyList/page.tsx
+++ b/frontend/app/(main)/admin/userMng/companyList/page.tsx
@ -1,105 +0,0 @@
 "use client";
 import { useCompanyManagement } from "@/hooks/useCompanyManagement";
 import { CompanyToolbar } from "@/components/admin/CompanyToolbar";
 import { CompanyTable } from "@/components/admin/CompanyTable";
 import { CompanyFormModal } from "@/components/admin/CompanyFormModal";
 import { CompanyDeleteDialog } from "@/components/admin/CompanyDeleteDialog";
 import { DiskUsageSummary } from "@/components/admin/DiskUsageSummary";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 회사 관리 페이지
 * 모든 회사 관리 기능을 통합하여 제공
 */
 export default function CompanyPage() {
  const {
    // 데이터
    companies,
    searchFilter,
    isLoading,
    error,
    // 디스크 사용량 관련
    diskUsageInfo,
    isDiskUsageLoading,
    loadDiskUsage,
    // 모달 상태
    modalState,
    deleteState,
    // 검색 기능
    updateSearchFilter,
    clearSearchFilter,
    // 모달 제어
    openCreateModal,
    openEditModal,
    closeModal,
    updateFormData,
    // 삭제 다이얼로그 제어
    openDeleteDialog,
    closeDeleteDialog,
    // CRUD 작업
    saveCompany,
    deleteCompany,
    // 에러 처리
    clearError,
  } = useCompanyManagement();
  return (
    <div className="flex min-h-screen flex-col bg-background">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">회사 관리</h1>
          <p className="text-sm text-muted-foreground">시스템에서 사용하는 회사 정보를 관리합니다</p>
        </div>
        {/* 디스크 사용량 요약 */}
        <DiskUsageSummary diskUsageInfo={diskUsageInfo} isLoading={isDiskUsageLoading} onRefresh={loadDiskUsage} />
        {/* 툴바 - 검색, 필터, 등록 버튼 */}
        <CompanyToolbar
          searchFilter={searchFilter}
          totalCount={companies.length}
          filteredCount={companies.length}
          onSearchChange={updateSearchFilter}
          onSearchClear={clearSearchFilter}
          onCreateClick={openCreateModal}
        />
        {/* 회사 목록 테이블 */}
        <CompanyTable companies={companies} isLoading={isLoading} onEdit={openEditModal} onDelete={openDeleteDialog} />
        {/* 회사 등록/수정 모달 */}
        <CompanyFormModal
          modalState={modalState}
          isLoading={isLoading}
          error={error}
          onClose={closeModal}
          onSave={saveCompany}
          onFormChange={updateFormData}
          onClearError={clearError}
        />
        {/* 회사 삭제 확인 다이얼로그 */}
        <CompanyDeleteDialog
          deleteState={deleteState}
          isLoading={isLoading}
          error={error}
          onClose={closeDeleteDialog}
          onConfirm={deleteCompany}
          onClearError={clearError}
        />
      </div>
      {/* Scroll to Top 버튼 */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/userMng/page.tsx
+++ b/frontend/app/(main)/admin/userMng/page.tsx
@ -0,0 +1,30 @@
 "use client";
 import { UserManagement } from "@/components/admin/UserManagement";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 사용자관리 페이지
 * URL: /admin/userMng
 *
 * shadcn/ui 스타일 가이드 적용
 */
 export default function UserMngPage() {
  return (
    <div className="flex min-h-screen flex-col bg-background">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">사용자 관리</h1>
          <p className="text-sm text-muted-foreground">시스템 사용자 계정 및 권한을 관리합니다</p>
        </div>
        {/* 메인 컨텐츠 */}
        <UserManagement />
      </div>
      {/* Scroll to Top 버튼 (모바일/태블릿 전용) */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/userMng/rolesList/page.tsx
+++ b/frontend/app/(main)/admin/userMng/rolesList/page.tsx
@ -1,364 +0,0 @@
 "use client";
 import React, { useState, useCallback, useEffect } from "react";
 import { Button } from "@/components/ui/button";
 import { Plus, Edit, Trash2, Users, Menu, Filter, X } from "lucide-react";
 import { roleAPI, RoleGroup } from "@/lib/api/role";
 import { useAuth } from "@/hooks/useAuth";
 import { AlertCircle } from "lucide-react";
 import { RoleFormModal } from "@/components/admin/RoleFormModal";
 import { RoleDeleteModal } from "@/components/admin/RoleDeleteModal";
 import { useRouter } from "next/navigation";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
 import { companyAPI } from "@/lib/api/company";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 권한 그룹 관리 페이지
 * URL: /admin/roles
 *
 * shadcn/ui 스타일 가이드 적용
 *
 * 기능:
 * - 회사별 권한 그룹 목록 조회
 * - 권한 그룹 생성/수정/삭제
 * - 멤버 관리 (Dual List Box)
 * - 메뉴 권한 설정 (CRUD 권한)
 * - 상세 페이지로 이동 (멤버 관리 + 메뉴 권한 설정)
 */
 export default function RolesPage() {
  const { user: currentUser } = useAuth();
  const router = useRouter();
  // 회사 관리자 또는 최고 관리자 여부
  const isAdmin =
    (currentUser?.companyCode === "*" && currentUser?.userType === "SUPER_ADMIN") ||
    currentUser?.userType === "COMPANY_ADMIN";
  const isSuperAdmin = currentUser?.companyCode === "*" && currentUser?.userType === "SUPER_ADMIN";
  // 상태 관리
  const [roleGroups, setRoleGroups] = useState<RoleGroup[]>([]);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
  // 회사 필터 (최고 관리자 전용)
  const [companies, setCompanies] = useState<Array<{ company_code: string; company_name: string }>>([]);
  const [selectedCompany, setSelectedCompany] = useState<string>("all");
  // 모달 상태
  const [formModal, setFormModal] = useState({
    isOpen: false,
    editingRole: null as RoleGroup | null,
  });
  const [deleteModal, setDeleteModal] = useState({
    isOpen: false,
    role: null as RoleGroup | null,
  });
  // 회사 목록 로드 (최고 관리자만)
  const loadCompanies = useCallback(async () => {
    if (!isSuperAdmin) return;
    try {
      const companies = await companyAPI.getList();
      setCompanies(companies);
    } catch (error) {
      console.error("회사 목록 로드 오류:", error);
    }
  }, [isSuperAdmin]);
  // 데이터 로드
  const loadRoleGroups = useCallback(async () => {
    setIsLoading(true);
    setError(null);
    try {
      // 최고 관리자: selectedCompany에 따라 필터링 (all이면 전체 조회)
      // 회사 관리자: 자기 회사만 조회
      const companyFilter =
        isSuperAdmin && selectedCompany !== "all"
          ? selectedCompany
          : isSuperAdmin
            ? undefined
            : currentUser?.companyCode;
      console.log("권한 그룹 목록 조회:", { isSuperAdmin, selectedCompany, companyFilter });
      const response = await roleAPI.getList({
        companyCode: companyFilter,
      });
      if (response.success && response.data) {
        setRoleGroups(response.data);
        console.log("권한 그룹 조회 성공:", response.data.length, "개");
      } else {
        setError(response.message || "권한 그룹 목록을 불러오는데 실패했습니다.");
      }
    } catch (err) {
      console.error("권한 그룹 목록 로드 오류:", err);
      setError("권한 그룹 목록을 불러오는 중 오류가 발생했습니다.");
    } finally {
      setIsLoading(false);
    }
  }, [isSuperAdmin, selectedCompany, currentUser?.companyCode]);
  useEffect(() => {
    if (isAdmin) {
      if (isSuperAdmin) {
        loadCompanies(); // 최고 관리자는 회사 목록 먼저 로드
      }
      loadRoleGroups();
    } else {
      setIsLoading(false);
    }
  }, [isAdmin, isSuperAdmin, loadRoleGroups, loadCompanies]);
  // 권한 그룹 생성 핸들러
  const handleCreateRole = useCallback(() => {
    setFormModal({ isOpen: true, editingRole: null });
  }, []);
  // 권한 그룹 수정 핸들러
  const handleEditRole = useCallback((role: RoleGroup) => {
    setFormModal({ isOpen: true, editingRole: role });
  }, []);
  // 권한 그룹 삭제 핸들러
  const handleDeleteRole = useCallback((role: RoleGroup) => {
    setDeleteModal({ isOpen: true, role });
  }, []);
  // 폼 모달 닫기
  const handleFormModalClose = useCallback(() => {
    setFormModal({ isOpen: false, editingRole: null });
  }, []);
  // 삭제 모달 닫기
  const handleDeleteModalClose = useCallback(() => {
    setDeleteModal({ isOpen: false, role: null });
  }, []);
  // 모달 성공 후 새로고침
  const handleModalSuccess = useCallback(() => {
    loadRoleGroups();
  }, [loadRoleGroups]);
  // 상세 페이지로 이동
  const handleViewDetail = useCallback(
    (role: RoleGroup) => {
      router.push(`/admin/userMng/rolesList/${role.objid}`);
    },
    [router],
  );
  // 관리자가 아니면 접근 제한
  if (!isAdmin) {
    return (
      <div className="flex min-h-screen flex-col bg-background">
        <div className="space-y-6 p-6">
          <div className="space-y-2 border-b pb-4">
            <h1 className="text-3xl font-bold tracking-tight">권한 그룹 관리</h1>
            <p className="text-sm text-muted-foreground">회사 내 권한 그룹을 생성하고 멤버를 관리합니다 (회사 관리자 이상)</p>
          </div>
          <div className="bg-card flex h-64 flex-col items-center justify-center rounded-lg border p-6 shadow-sm">
            <AlertCircle className="text-destructive mb-4 h-12 w-12" />
            <h3 className="mb-2 text-lg font-semibold">접근 권한 없음</h3>
            <p className="text-muted-foreground mb-4 text-center text-sm">
              권한 그룹 관리는 회사 관리자 이상만 접근할 수 있습니다.
            </p>
            <Button variant="outline" onClick={() => window.history.back()}>
              뒤로 가기
            </Button>
          </div>
        </div>
        <ScrollToTop />
      </div>
    );
  }
  return (
    <div className="flex min-h-screen flex-col bg-background">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">권한 그룹 관리</h1>
          <p className="text-sm text-muted-foreground">회사 내 권한 그룹을 생성하고 멤버를 관리합니다 (회사 관리자 이상)</p>
        </div>
        {/* 에러 메시지 */}
        {error && (
          <div className="border-destructive/50 bg-destructive/10 rounded-lg border p-4">
            <div className="flex items-center justify-between">
              <p className="text-destructive text-sm font-semibold">오류가 발생했습니다</p>
              <button
                onClick={() => setError(null)}
                className="text-destructive hover:text-destructive/80 transition-colors"
                aria-label="에러 메시지 닫기"
              >
                ✕
              </button>
            </div>
            <p className="text-destructive/80 mt-1.5 text-sm">{error}</p>
          </div>
        )}
        {/* 액션 버튼 영역 */}
        <div className="flex flex-col gap-4 lg:flex-row lg:items-center lg:justify-between">
          <div className="flex items-center gap-4">
            <h2 className="text-xl font-semibold">권한 그룹 목록 ({roleGroups.length})</h2>
            {/* 최고 관리자 전용: 회사 필터 */}
            {isSuperAdmin && (
              <div className="flex items-center gap-2">
                <Filter className="text-muted-foreground h-4 w-4" />
                <Select value={selectedCompany} onValueChange={(value) => setSelectedCompany(value)}>
                  <SelectTrigger className="h-10 w-[200px]">
                    <SelectValue placeholder="회사 선택" />
                  </SelectTrigger>
                  <SelectContent>
                    <SelectItem value="all">전체 회사</SelectItem>
                    {companies.map((company) => (
                      <SelectItem key={company.company_code} value={company.company_code}>
                        {company.company_name}
                      </SelectItem>
                    ))}
                  </SelectContent>
                </Select>
                {selectedCompany !== "all" && (
                  <Button variant="ghost" size="sm" onClick={() => setSelectedCompany("all")} className="h-8 w-8 p-0">
                    <X className="h-4 w-4" />
                  </Button>
                )}
              </div>
            )}
          </div>
          <Button onClick={handleCreateRole} className="gap-2">
            <Plus className="h-4 w-4" />
            권한 그룹 생성
          </Button>
        </div>
        {/* 권한 그룹 목록 */}
        {isLoading ? (
          <div className="bg-card rounded-lg border p-12 shadow-sm">
            <div className="flex flex-col items-center justify-center gap-4">
              <div className="border-primary h-8 w-8 animate-spin rounded-full border-4 border-t-transparent"></div>
              <p className="text-muted-foreground text-sm">권한 그룹 목록을 불러오는 중...</p>
            </div>
          </div>
        ) : roleGroups.length === 0 ? (
          <div className="bg-card flex h-64 flex-col items-center justify-center rounded-lg border shadow-sm">
            <div className="flex flex-col items-center gap-2 text-center">
              <p className="text-muted-foreground text-sm">등록된 권한 그룹이 없습니다.</p>
              <p className="text-muted-foreground text-xs">권한 그룹을 생성하여 멤버를 관리해보세요.</p>
            </div>
          </div>
        ) : (
          <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
            {roleGroups.map((role) => (
              <div key={role.objid} className="bg-card rounded-lg border shadow-sm transition-colors">
                {/* 헤더 (클릭 시 상세 페이지) */}
                <div
                  className="hover:bg-muted/50 cursor-pointer p-4 transition-colors"
                  onClick={() => handleViewDetail(role)}
                >
                  <div className="mb-4 flex items-start justify-between">
                    <div className="flex-1">
                      <h3 className="text-base font-semibold">{role.authName}</h3>
                      <p className="text-muted-foreground mt-1 font-mono text-sm">{role.authCode}</p>
                    </div>
                    <span
                      className={`rounded-full px-2 py-1 text-xs font-medium ${
                        role.status === "active" ? "bg-green-100 text-green-800" : "bg-gray-100 text-gray-800"
                      }`}
                    >
                      {role.status === "active" ? "활성" : "비활성"}
                    </span>
                  </div>
                  {/* 정보 */}
                  <div className="space-y-2 border-t pt-4">
                    {/* 최고 관리자는 회사명 표시 */}
                    {isSuperAdmin && (
                      <div className="flex justify-between text-sm">
                        <span className="text-muted-foreground">회사</span>
                        <span className="font-medium">
                          {companies.find((c) => c.company_code === role.companyCode)?.company_name || role.companyCode}
                        </span>
                      </div>
                    )}
                    <div className="flex justify-between text-sm">
                      <span className="text-muted-foreground flex items-center gap-1">
                        <Users className="h-3 w-3" />
                        멤버 수
                      </span>
                      <span className="font-medium">{role.memberCount || 0}명</span>
                    </div>
                    <div className="flex justify-between text-sm">
                      <span className="text-muted-foreground flex items-center gap-1">
                        <Menu className="h-3 w-3" />
                        메뉴 권한
                      </span>
                      <span className="font-medium">{role.menuCount || 0}개</span>
                    </div>
                  </div>
                </div>
                {/* 액션 버튼 */}
                <div className="flex gap-2 border-t p-3">
                  <Button
                    variant="outline"
                    size="sm"
                    onClick={(e) => {
                      e.stopPropagation();
                      handleEditRole(role);
                    }}
                    className="flex-1 gap-1 text-xs"
                  >
                    <Edit className="h-3 w-3" />
                    수정
                  </Button>
                  <Button
                    variant="outline"
                    size="sm"
                    onClick={(e) => {
                      e.stopPropagation();
                      handleDeleteRole(role);
                    }}
                    className="text-destructive hover:bg-destructive hover:text-destructive-foreground gap-1 text-xs"
                  >
                    <Trash2 className="h-3 w-3" />
                    삭제
                  </Button>
                </div>
              </div>
            ))}
          </div>
        )}
        {/* 모달들 */}
        <RoleFormModal
          isOpen={formModal.isOpen}
          onClose={handleFormModalClose}
          onSuccess={handleModalSuccess}
          editingRole={formModal.editingRole}
        />
        <RoleDeleteModal
          isOpen={deleteModal.isOpen}
          onClose={handleDeleteModalClose}
          onSuccess={handleModalSuccess}
          role={deleteModal.role}
        />
      </div>
      {/* Scroll to Top 버튼 (모바일/태블릿 전용) */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/userMng/userAuthList/page.tsx
+++ b/frontend/app/(main)/admin/userMng/userAuthList/page.tsx
@ -1,181 +0,0 @@
 "use client";
 import React, { useState, useCallback, useEffect } from "react";
 import { UserAuthTable } from "@/components/admin/UserAuthTable";
 import { UserAuthEditModal } from "@/components/admin/UserAuthEditModal";
 import { userAPI } from "@/lib/api/user";
 import { useAuth } from "@/hooks/useAuth";
 import { AlertCircle } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 사용자 권한 관리 페이지
 * URL: /admin/userAuth
 *
 * 최고 관리자만 접근 가능
 * 사용자별 권한 레벨(SUPER_ADMIN, COMPANY_ADMIN, USER 등) 관리
 */
 export default function UserAuthPage() {
  const { user: currentUser } = useAuth();
  // 최고 관리자 여부
  const isSuperAdmin = currentUser?.companyCode === "*" && currentUser?.userType === "SUPER_ADMIN";
  // 상태 관리
  const [users, setUsers] = useState<any[]>([]);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
  const [paginationInfo, setPaginationInfo] = useState({
    currentPage: 1,
    pageSize: 20,
    totalItems: 0,
    totalPages: 0,
  });
  // 권한 변경 모달
  const [authEditModal, setAuthEditModal] = useState({
    isOpen: false,
    user: null as any | null,
  });
  // 데이터 로드
  const loadUsers = useCallback(
    async (page: number = 1) => {
      setIsLoading(true);
      setError(null);
      try {
        const response = await userAPI.getList({
          page,
          size: paginationInfo.pageSize,
        });
        if (response.success && response.data) {
          setUsers(response.data);
          setPaginationInfo({
            currentPage: response.currentPage || page,
            pageSize: response.pageSize || paginationInfo.pageSize,
            totalItems: response.total || 0,
            totalPages: Math.ceil((response.total || 0) / (response.pageSize || paginationInfo.pageSize)),
          });
        } else {
          setError(response.message || "사용자 목록을 불러오는데 실패했습니다.");
        }
      } catch (err) {
        console.error("사용자 목록 로드 오류:", err);
        setError("사용자 목록을 불러오는 중 오류가 발생했습니다.");
      } finally {
        setIsLoading(false);
      }
    },
    [paginationInfo.pageSize],
  );
  useEffect(() => {
    loadUsers(1);
  }, []);
  // 권한 변경 핸들러
  const handleEditAuth = (user: any) => {
    setAuthEditModal({
      isOpen: true,
      user,
    });
  };
  // 권한 변경 모달 닫기
  const handleAuthEditClose = () => {
    setAuthEditModal({
      isOpen: false,
      user: null,
    });
  };
  // 권한 변경 성공
  const handleAuthEditSuccess = () => {
    loadUsers(paginationInfo.currentPage);
    handleAuthEditClose();
  };
  // 페이지 변경
  const handlePageChange = (page: number) => {
    loadUsers(page);
  };
  // 최고 관리자가 아닌 경우
  if (!isSuperAdmin) {
    return (
      <div className="bg-background flex min-h-screen flex-col">
        <div className="space-y-6 p-6">
          <div className="space-y-2 border-b pb-4">
            <h1 className="text-3xl font-bold tracking-tight">사용자 권한 관리</h1>
            <p className="text-muted-foreground text-sm">사용자별 권한 레벨을 관리합니다. (최고 관리자 전용)</p>
          </div>
          <div className="bg-card flex h-64 flex-col items-center justify-center rounded-lg border p-6 shadow-sm">
            <AlertCircle className="text-destructive mb-4 h-12 w-12" />
            <h3 className="mb-2 text-lg font-semibold">접근 권한 없음</h3>
            <p className="text-muted-foreground mb-4 text-center text-sm">
              권한 관리는 최고 관리자만 접근할 수 있습니다.
            </p>
            <Button variant="outline" onClick={() => window.history.back()}>
              뒤로 가기
            </Button>
          </div>
        </div>
        <ScrollToTop />
      </div>
    );
  }
  return (
    <div className="bg-background flex min-h-screen flex-col">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">사용자 권한 관리</h1>
          <p className="text-muted-foreground text-sm">사용자별 권한 레벨을 관리합니다. (최고 관리자 전용)</p>
        </div>
        {/* 에러 메시지 */}
        {error && (
          <div className="border-destructive/50 bg-destructive/10 rounded-lg border p-4">
            <div className="flex items-center justify-between">
              <p className="text-destructive text-sm font-semibold">오류가 발생했습니다</p>
              <button
                onClick={() => setError(null)}
                className="text-destructive hover:text-destructive/80 transition-colors"
                aria-label="에러 메시지 닫기"
              >
                ✕
              </button>
            </div>
            <p className="text-destructive/80 mt-1.5 text-sm">{error}</p>
          </div>
        )}
        {/* 사용자 권한 테이블 */}
        <UserAuthTable
          users={users}
          isLoading={isLoading}
          paginationInfo={paginationInfo}
          onEditAuth={handleEditAuth}
          onPageChange={handlePageChange}
        />
        {/* 권한 변경 모달 */}
        <UserAuthEditModal
          isOpen={authEditModal.isOpen}
          onClose={handleAuthEditClose}
          onSuccess={handleAuthEditSuccess}
          user={authEditModal.user}
        />
      </div>
      {/* Scroll to Top 버튼 (모바일/태블릿 전용) */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/admin/userMng/userMngList/page.tsx
+++ b/frontend/app/(main)/admin/userMng/userMngList/page.tsx
@ -1,190 +0,0 @@
 "use client";
 import { useState } from "react";
 import { useUserManagement } from "@/hooks/useUserManagement";
 import { UserToolbar } from "@/components/admin/UserToolbar";
 import { UserTable } from "@/components/admin/UserTable";
 import { Pagination } from "@/components/common/Pagination";
 import { UserPasswordResetModal } from "@/components/admin/UserPasswordResetModal";
 import { UserFormModal } from "@/components/admin/UserFormModal";
 import { ScrollToTop } from "@/components/common/ScrollToTop";
 /**
 * 사용자관리 페이지
 * URL: /admin/userMng
 *
 * shadcn/ui 스타일 가이드 적용
 * - 원본 Spring + JSP 코드 패턴 기반 REST API 연동
 * - 실제 데이터베이스와 연동되어 작동
 */
 export default function UserMngPage() {
  const {
    // 데이터
    users,
    searchFilter,
    isLoading,
    isSearching,
    error,
    paginationInfo,
    // 검색 기능
    updateSearchFilter,
    // 페이지네이션
    handlePageChange,
    handlePageSizeChange,
    // 액션 핸들러
    handleStatusToggle,
    // 유틸리티
    clearError,
    refreshData,
  } = useUserManagement();
  // 비밀번호 초기화 모달 상태
  const [passwordResetModal, setPasswordResetModal] = useState({
    isOpen: false,
    userId: null as string | null,
    userName: null as string | null,
  });
  // 사용자 등록/수정 모달 상태
  const [userFormModal, setUserFormModal] = useState({
    isOpen: false,
    editingUser: null as any | null,
  });
  // 사용자 등록 핸들러
  const handleCreateUser = () => {
    setUserFormModal({
      isOpen: true,
      editingUser: null,
    });
  };
  // 사용자 수정 핸들러
  const handleEditUser = (user: any) => {
    setUserFormModal({
      isOpen: true,
      editingUser: user,
    });
  };
  // 사용자 등록/수정 모달 닫기
  const handleUserFormClose = () => {
    setUserFormModal({
      isOpen: false,
      editingUser: null,
    });
  };
  // 사용자 등록/수정 성공 핸들러
  const handleUserFormSuccess = () => {
    refreshData();
    handleUserFormClose();
  };
  // 비밀번호 초기화 핸들러
  const handlePasswordReset = (userId: string, userName: string) => {
    setPasswordResetModal({
      isOpen: true,
      userId,
      userName,
    });
  };
  // 비밀번호 초기화 모달 닫기
  const handlePasswordResetClose = () => {
    setPasswordResetModal({
      isOpen: false,
      userId: null,
      userName: null,
    });
  };
  // 비밀번호 초기화 성공 핸들러
  const handlePasswordResetSuccess = () => {
    handlePasswordResetClose();
  };
  return (
    <div className="flex min-h-screen flex-col bg-background">
      <div className="space-y-6 p-6">
        {/* 페이지 헤더 */}
        <div className="space-y-2 border-b pb-4">
          <h1 className="text-3xl font-bold tracking-tight">사용자 관리</h1>
          <p className="text-sm text-muted-foreground">시스템 사용자 계정 및 권한을 관리합니다</p>
        </div>
        {/* 툴바 - 검색, 필터, 등록 버튼 */}
        <UserToolbar
          searchFilter={searchFilter}
          totalCount={paginationInfo.totalItems}
          isSearching={isSearching}
          onSearchChange={updateSearchFilter}
          onCreateClick={handleCreateUser}
        />
        {/* 에러 메시지 */}
        {error && (
          <div className="border-destructive/50 bg-destructive/10 rounded-lg border p-4">
            <div className="flex items-center justify-between">
              <p className="text-destructive text-sm font-semibold">오류가 발생했습니다</p>
              <button
                onClick={clearError}
                className="text-destructive hover:text-destructive/80 transition-colors"
                aria-label="에러 메시지 닫기"
              >
                ✕
              </button>
            </div>
            <p className="text-destructive/80 mt-1.5 text-sm">{error}</p>
          </div>
        )}
        {/* 사용자 목록 테이블 */}
        <UserTable
          users={users}
          isLoading={isLoading}
          paginationInfo={paginationInfo}
          onStatusToggle={handleStatusToggle}
          onPasswordReset={handlePasswordReset}
          onEdit={handleEditUser}
        />
        {/* 페이지네이션 */}
        {!isLoading && users.length > 0 && (
          <Pagination
            paginationInfo={paginationInfo}
            onPageChange={handlePageChange}
            onPageSizeChange={handlePageSizeChange}
            showPageSizeSelector={true}
            pageSizeOptions={[10, 20, 50, 100]}
            className="mt-6"
          />
        )}
        {/* 사용자 등록/수정 모달 */}
        <UserFormModal
          isOpen={userFormModal.isOpen}
          onClose={handleUserFormClose}
          onSuccess={handleUserFormSuccess}
          editingUser={userFormModal.editingUser}
        />
        {/* 비밀번호 초기화 모달 */}
        <UserPasswordResetModal
          isOpen={passwordResetModal.isOpen}
          onClose={handlePasswordResetClose}
          userId={passwordResetModal.userId}
          userName={passwordResetModal.userName}
          onSuccess={handlePasswordResetSuccess}
        />
      </div>
      {/* Scroll to Top 버튼 (모바일/태블릿 전용) */}
      <ScrollToTop />
    </div>
  );
 }
--- a/frontend/app/(main)/dashboard/[dashboardId]/page.tsx
+++ b/frontend/app/(main)/dashboard/[dashboardId]/page.tsx
@ -142,7 +142,7 @@ export default function DashboardViewPage({ params }: DashboardViewPageProps) {
            {/* 편집 버튼 *\/}
            <button
              onClick={() => {
-                router.push(`/admin/screenMng/dashboardList?load=${resolvedParams.dashboardId}`);
+                router.push(`/admin/dashboard?load=${resolvedParams.dashboardId}`);
              }}
              className="rounded-lg bg-blue-500 px-4 py-2 text-white hover:bg-blue-600"
            >
--- a/frontend/app/(main)/dashboard/page.tsx
+++ b/frontend/app/(main)/dashboard/page.tsx
@ -130,7 +130,7 @@ export default function DashboardListPage() {
            </div>
            <Link
-              href="/admin/screenMng/dashboardList"
+              href="/admin/dashboard"
              className="rounded-lg bg-primary px-6 py-3 font-medium text-primary-foreground hover:bg-primary/90"
            >
              ➕ 새 대시보드 만들기
@ -185,7 +185,7 @@ export default function DashboardListPage() {
            </p>
            {!searchTerm && (
              <Link
-                href="/admin/screenMng/dashboardList"
+                href="/admin/dashboard"
                className="inline-flex items-center rounded-lg bg-primary px-6 py-3 font-medium text-primary-foreground hover:bg-primary/90"
              >
                ➕ 대시보드 만들기
@ -251,7 +251,7 @@ function DashboardCard({ dashboard }: DashboardCardProps) {
            보기
          </Link>
          <Link
-            href={`/admin/screenMng/dashboardList?load=${dashboard.id}`}
+            href={`/admin/dashboard?load=${dashboard.id}`}
            className="rounded-lg border border-input bg-background px-4 py-2 text-sm text-foreground hover:bg-accent hover:text-accent-foreground"
          >
            편집
--- a/frontend/app/(main)/main/page.tsx
+++ b/frontend/app/(main)/main/page.tsx
@ -10,6 +10,7 @@ import { Badge } from "@/components/ui/badge";
 export default function MainPage() {
  return (
    <div className="space-y-6 p-4">
      {/* 메인 컨텐츠 */}
      {/* Welcome Message */}
      <Card>
        <CardContent className="pt-6">
--- a/frontend/app/(main)/screens/[screenId]/page.tsx
+++ b/frontend/app/(main)/screens/[screenId]/page.tsx
@ -33,17 +33,8 @@ function ScreenViewPage() {
  // URL 쿼리에서 menuObjid 가져오기 (메뉴 스코프)
  const menuObjid = searchParams.get("menuObjid") ? parseInt(searchParams.get("menuObjid")!) : undefined;
  // URL 쿼리에서 프리뷰용 company_code 가져오기
  const previewCompanyCode = searchParams.get("company_code");
  // 프리뷰 모드 감지 (iframe에서 로드될 때)
  const isPreviewMode = searchParams.get("preview") === "true";
  // 🆕 현재 로그인한 사용자 정보
-  const { user, userName, companyCode: authCompanyCode } = useAuth();
+  const { user, userName, companyCode } = useAuth();
  // 프리뷰 모드에서는 URL 파라미터의 company_code 우선 사용
  const companyCode = previewCompanyCode || authCompanyCode;
  // 🆕 모바일 환경 감지
  const { isMobile } = useResponsive();
@ -242,40 +233,27 @@ function ScreenViewPage() {
        const designWidth = layout?.screenResolution?.width || 1200;
        const designHeight = layout?.screenResolution?.height || 800;
-        // 컨테이너의 실제 크기 (프리뷰 모드에서는 window 크기 사용)
+        // 컨테이너의 실제 크기
-        let containerWidth: number;
+        const containerWidth = containerRef.current.offsetWidth;
-        let containerHeight: number;
+        const containerHeight = containerRef.current.offsetHeight;
-        if (isPreviewMode) {
+        // 여백 설정: 좌우 16px씩 (총 32px), 상단 패딩 32px (pt-8)
          // iframe에서는 window 크기를 직접 사용
          containerWidth = window.innerWidth;
          containerHeight = window.innerHeight;
        } else {
          containerWidth = containerRef.current.offsetWidth;
          containerHeight = containerRef.current.offsetHeight;
        }
        let newScale: number;
        if (isPreviewMode) {
          // 프리뷰 모드: 가로/세로 모두 fit하도록 (여백 없이)
          const scaleX = containerWidth / designWidth;
          const scaleY = containerHeight / designHeight;
          newScale = Math.min(scaleX, scaleY, 1); // 최대 1배율
        } else {
          // 일반 모드: 가로 기준 스케일 (좌우 여백 16px씩 고정)
        const MARGIN_X = 32;
        const availableWidth = containerWidth - MARGIN_X;
-          newScale = availableWidth / designWidth;
+
-        }
+        // 가로 기준 스케일 계산 (좌우 여백 16px씩 고정)
        const newScale = availableWidth / designWidth;
        // console.log("📐 스케일 계산:", {
        //   containerWidth,
        //   containerHeight,
        //   MARGIN_X,
        //   availableWidth,
        //   designWidth,
        //   designHeight,
        //   finalScale: newScale,
-        //   isPreviewMode,
+        //   "스케일된 화면 크기": `${designWidth * newScale}px × ${designHeight * newScale}px`,
        //   "실제 좌우 여백": `${(containerWidth - designWidth * newScale) / 2}px씩`,
        // });
        setScale(newScale);
@ -294,7 +272,7 @@ function ScreenViewPage() {
    return () => {
      clearTimeout(timer);
    };
-  }, [layout, isMobile, isPreviewMode]);
+  }, [layout, isMobile]);
  if (loading) {
    return (
@ -332,7 +310,7 @@ function ScreenViewPage() {
    <ScreenPreviewProvider isPreviewMode={false}>
      <ActiveTabProvider>
        <TableOptionsProvider>
-        <div ref={containerRef} className={`bg-background h-full w-full ${isPreviewMode ? "overflow-hidden p-0" : "overflow-auto p-3"}`}>
+        <div ref={containerRef} className="bg-background h-full w-full overflow-auto p-3">
          {/* 레이아웃 준비 중 로딩 표시 */}
          {!layoutReady && (
            <div className="from-muted to-muted/50 flex h-full w-full items-center justify-center bg-gradient-to-br">
--- a/Show More
+++ b/Show More
		`@ -587,5 +587,3 @@ const result = await executeNodeFlow(flowId, {`
		`@ -346,5 +346,3 @@ const getComponentValue = (componentId: string) => {`