Added improvements

mrjung72 · mrjung72 · commit 7f50b868c808 · 2025-10-14T21:36:18.000+09:00
1. Sheet name verification logic is also applied to file verification logic.
2. Added XML element and attribute name validation logic
diff --git a/app.js b/app.js
@@ -174,11 +174,7 @@ function question(query) {
 function pause() {
     return new Promise(resolve => {
         console.log(`\n${msg.pressAnyKey}`);
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.once('data', () => {
-            process.stdin.setRawMode(false);
-            process.stdin.pause();
+        rl.question('', () => {
             resolve();
         });
     });
diff --git a/src/excel-cli.js b/src/excel-cli.js
@@ -7,6 +7,46 @@ const yargs = require('yargs');
 const args = process.argv.slice(2);
 const command = args[0];
 
+/**
+ * 시트명 유효성 검증
+ * @param {string} sheetName - 검증할 시트명
+ * @param {boolean} skipLengthCheck - 길이 검증 건너뛰기 (변수 포함 시)
+ * @returns {Object} { valid: boolean, errors: string[] }
+ */
+function validateSheetName(sheetName, skipLengthCheck = false) {
+    const errors = [];
+    
+    // Excel 시트명에 사용할 수 없는 문자
+    const invalidChars = ['\\', '/', '*', '?', '[', ']', ':'];
+    
+    // 1. 빈 문자열 체크
+    if (!sheetName || sheetName.trim() === '') {
+        errors.push('시트명이 비어있습니다.');
+        return { valid: false, errors };
+    }
+    
+    // 2. 최대 길이 체크 (31자) - 변수 포함 시 건너뛰기
+    if (!skipLengthCheck && sheetName.length > 31) {
+        errors.push(`시트명이 너무 깁니다 (최대 31자, 현재: ${sheetName.length}자)`);
+    }
+    
+    // 3. 허용되지 않는 문자 체크
+    const foundInvalidChars = invalidChars.filter(char => sheetName.includes(char));
+    if (foundInvalidChars.length > 0) {
+        errors.push(`허용되지 않는 문자 포함: ${foundInvalidChars.join(', ')}`);
+    }
+    
+    // 4. 시트명 시작/끝 공백 체크
+    if (sheetName !== sheetName.trim()) {
+        errors.push('시트명 앞뒤에 공백이 있습니다.');
+    }
+    
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+
 // 도움말 표시
 function showHelp() {
     console.log(`
@@ -271,18 +311,39 @@ async function validateQueryFile(options) {
                 // 쿼리 정의 수집
                 const queryDefArray = Array.isArray(parsed.queries.queryDefs[0].queryDef) ? parsed.queries.queryDefs[0].queryDef : [parsed.queries.queryDefs[0].queryDef];
                 queryDefArray.forEach(def => {
-                    if (def.$ && def.$.name) {
-                        queryDefs[def.$.name] = true;
+                    if (def.$ && (def.$.id || def.$.name)) {
+                        const queryId = def.$.id || def.$.name;
+                        queryDefs[queryId] = true;
+                        console.log(`   [DEBUG] queryDef 발견: ${queryId}`);
                     }
                 });
+                console.log(`   [DEBUG] 총 ${Object.keys(queryDefs).length}개의 queryDef: ${Object.keys(queryDefs).join(', ')}`);
                 
-                // 쿼리 참조 검증
+                // 쿼리 참조 검증 및 시트명 검증
                 for (const sheet of sheets) {
-                    if (sheet.$ && sheet.$.queryRef) {
-                        if (!queryDefs[sheet.$.queryRef]) {
-                            throw new Error(`시트 "${sheet.$.name}"에서 참조하는 쿼리 정의 "${sheet.$.queryRef}"를 찾을 수 없습니다.`);
+                    if (sheet.$) {
+                        // 시트명 검증 (변수 치환 전이므로 변수 포함 가능)
+                        const sheetName = sheet.$.name || '';
+                        
+                        // 시트명 검증 (변수 포함 시 길이 검증만 건너뛰기)
+                        const hasVariables = sheetName.includes('${');
+                        const sheetNameValidation = validateSheetName(sheetName, hasVariables);
+                        if (!sheetNameValidation.valid) {
+                            console.error(`\n❌ 시트명 검증 실패:`);
+                            console.error(`   시트명: "${sheetName}"`);
+                            sheetNameValidation.errors.forEach(error => {
+                                console.error(`   - ${error}`);
+                            });
+                            throw new Error(`시트명 검증 실패: "${sheetName}"`);
+                        }
+                        
+                        // 쿼리 참조 검증
+                        if (sheet.$.queryRef) {
+                            if (!queryDefs[sheet.$.queryRef]) {
+                                throw new Error(`시트 "${sheetName}"에서 참조하는 쿼리 정의 "${sheet.$.queryRef}"를 찾을 수 없습니다.`);
+                            }
+                            console.log(`   ✅ 시트 "${sheetName}" -> 쿼리 정의 "${sheet.$.queryRef}" 참조 확인`);
                         }
-                        console.log(`   ✅ 시트 "${sheet.$.name}" -> 쿼리 정의 "${sheet.$.queryRef}" 참조 확인`);
                     }
                 }
             }
@@ -303,13 +364,28 @@ async function validateQueryFile(options) {
                 const queryDefCount = Object.keys(parsed.queryDefs).length;
                 console.log(`   쿼리 정의 개수: ${queryDefCount}개`);
                 
-                // 쿼리 참조 검증
+                // 쿼리 참조 검증 및 시트명 검증
                 for (const sheet of parsed.sheets) {
+                    const sheetName = sheet.name || '';
+                    
+                    // 시트명 검증 (변수 포함 시 길이 검증만 건너뛰기)
+                    const hasVariables = sheetName.includes('${');
+                    const sheetNameValidation = validateSheetName(sheetName, hasVariables);
+                    if (!sheetNameValidation.valid) {
+                        console.error(`\n❌ 시트명 검증 실패:`);
+                        console.error(`   시트명: "${sheetName}"`);
+                        sheetNameValidation.errors.forEach(error => {
+                            console.error(`   - ${error}`);
+                        });
+                        throw new Error(`시트명 검증 실패: "${sheetName}"`);
+                    }
+                    
+                    // 쿼리 참조 검증
                     if (sheet.queryRef) {
                         if (!parsed.queryDefs[sheet.queryRef]) {
-                            throw new Error(`시트 "${sheet.name}"에서 참조하는 쿼리 정의 "${sheet.queryRef}"를 찾을 수 없습니다.`);
+                            throw new Error(`시트 "${sheetName}"에서 참조하는 쿼리 정의 "${sheet.queryRef}"를 찾을 수 없습니다.`);
                         }
-                        console.log(`   ✅ 시트 "${sheet.name}" -> 쿼리 정의 "${sheet.queryRef}" 참조 확인`);
+                        console.log(`   ✅ 시트 "${sheetName}" -> 쿼리 정의 "${sheet.queryRef}" 참조 확인`);
                     }
                 }
             }
@@ -332,7 +408,10 @@ async function validateQueryFile(options) {
 // main 함수
 async function main() {
     try {
+        console.log('[DEBUG] args:', args);
+        console.log('[DEBUG] command:', command);
         const options = parseOptions(args.slice(1));
+        console.log('[DEBUG] options:', options);
         
         // 명령어 정보 출력
         if (command !== 'list-dbs') {
diff --git a/src/index.js b/src/index.js
@@ -188,6 +188,17 @@ async function main() {
     let sql = variableProcessor.substituteVars(sheetDef.query, mergedVars, sheetDef.params || {});
     const sheetName = variableProcessor.substituteVars(sheetDef.name, mergedVars, sheetDef.params || {});
     
+    // 시트명 검증 (변수 치환 후)
+    const sheetNameValidation = queryParser.validateSheetName(sheetName, i);
+    if (!sheetNameValidation.valid) {
+      console.error(`\n❌ 시트명 검증 실패 (시트 #${i + 1}):`);
+      console.error(`   시트명: "${sheetName}"`);
+      sheetNameValidation.errors.forEach(error => {
+        console.error(`   - ${error}`);
+      });
+      throw new Error(`시트명 검증 실패: "${sheetName}"`);
+    }
+    
     // maxRows 제한 적용 (개별 시트 설정 > 전역 설정 우선)
     const effectiveMaxRows = sheetDef.maxRows || globalMaxRows;
     if (effectiveMaxRows && effectiveMaxRows > 0) {
diff --git a/src/query-parser.js b/src/query-parser.js
@@ -51,6 +51,141 @@ class QueryParser {
     };
   }
 
+  /**
+   * XML 구조 검증 (element명과 속성명)
+   * @param {Object} parsed - 파싱된 XML 객체
+   * @returns {Object} { valid: boolean, errors: string[] }
+   */
+  validateXMLStructure(parsed) {
+    const errors = [];
+    
+    // 허용되는 최상위 element
+    const allowedRootElements = ['queries'];
+    
+    // 허용되는 element와 그 속성 정의
+    const allowedElements = {
+      queries: ['excel', 'vars', 'dynamicVars', 'queryDefs', 'sheet'],
+      excel: [], // 자식 element 없음
+      vars: ['var'],
+      var: [], // 자식 element 없음
+      dynamicVars: ['dynamicVar'],
+      dynamicVar: [], // 자식 element 없음
+      queryDefs: ['queryDef'],
+      queryDef: [], // 자식 element 없음
+      sheet: ['params'],
+      params: ['param'],
+      param: [] // 자식 element 없음
+    };
+    
+    // 허용되는 속성 정의
+    const allowedAttributes = {
+      excel: ['db', 'output', 'maxRows', 'style', 'aggregateInfoTemplate'],
+      var: ['name'],
+      dynamicVar: ['name', 'description', 'type', 'database'],
+      queryDef: ['id', 'description'],
+      sheet: ['name', 'use', 'queryRef', 'aggregateColumn', 'aggregateInfoTemplate', 'maxRows', 'db', 'style'],
+      param: ['name']
+    };
+    
+    // 최상위 element 검증
+    const rootElementNames = Object.keys(parsed);
+    const invalidRootElements = rootElementNames.filter(name => !allowedRootElements.includes(name));
+    if (invalidRootElements.length > 0) {
+      errors.push(`허용되지 않는 최상위 element: ${invalidRootElements.join(', ')}`);
+    }
+    
+    // queries element 검증
+    if (parsed.queries) {
+      const queries = parsed.queries;
+      const queryKeys = Object.keys(queries);
+      const invalidElements = queryKeys.filter(key => !allowedElements.queries.includes(key));
+      if (invalidElements.length > 0) {
+        errors.push(`queries 내 허용되지 않는 element: ${invalidElements.join(', ')}`);
+      }
+      
+      // excel element 속성 검증
+      if (queries.excel && queries.excel[0] && queries.excel[0].$) {
+        const excelAttrs = Object.keys(queries.excel[0].$);
+        const invalidAttrs = excelAttrs.filter(attr => !allowedAttributes.excel.includes(attr));
+        if (invalidAttrs.length > 0) {
+          errors.push(`excel element의 허용되지 않는 속성: ${invalidAttrs.join(', ')}`);
+        }
+      }
+      
+      // var elements 검증
+      if (queries.vars && queries.vars[0] && queries.vars[0].var) {
+        queries.vars[0].var.forEach((v, i) => {
+          if (v.$) {
+            const attrs = Object.keys(v.$);
+            const invalidAttrs = attrs.filter(attr => !allowedAttributes.var.includes(attr));
+            if (invalidAttrs.length > 0) {
+              errors.push(`var element #${i + 1}의 허용되지 않는 속성: ${invalidAttrs.join(', ')}`);
+            }
+          }
+        });
+      }
+      
+      // dynamicVar elements 검증
+      if (queries.dynamicVars && queries.dynamicVars[0] && queries.dynamicVars[0].dynamicVar) {
+        queries.dynamicVars[0].dynamicVar.forEach((dv, i) => {
+          if (dv.$) {
+            const attrs = Object.keys(dv.$);
+            const invalidAttrs = attrs.filter(attr => !allowedAttributes.dynamicVar.includes(attr));
+            if (invalidAttrs.length > 0) {
+              errors.push(`dynamicVar element #${i + 1}의 허용되지 않는 속성: ${invalidAttrs.join(', ')}`);
+            }
+          }
+        });
+      }
+      
+      // queryDef elements 검증
+      if (queries.queryDefs && queries.queryDefs[0] && queries.queryDefs[0].queryDef) {
+        queries.queryDefs[0].queryDef.forEach((qd, i) => {
+          if (qd.$) {
+            const attrs = Object.keys(qd.$);
+            const invalidAttrs = attrs.filter(attr => !allowedAttributes.queryDef.includes(attr));
+            if (invalidAttrs.length > 0) {
+              errors.push(`queryDef element #${i + 1}의 허용되지 않는 속성: ${invalidAttrs.join(', ')}`);
+            }
+          }
+        });
+      }
+      
+      // sheet elements 검증
+      if (queries.sheet) {
+        const sheets = Array.isArray(queries.sheet) ? queries.sheet : [queries.sheet];
+        sheets.forEach((sheet, i) => {
+          if (sheet.$) {
+            const attrs = Object.keys(sheet.$);
+            const invalidAttrs = attrs.filter(attr => !allowedAttributes.sheet.includes(attr));
+            if (invalidAttrs.length > 0) {
+              errors.push(`sheet element #${i + 1}의 허용되지 않는 속성: ${invalidAttrs.join(', ')}`);
+            }
+          }
+          
+          // params 검증
+          if (sheet.params && sheet.params[0] && sheet.params[0].param) {
+            const params = Array.isArray(sheet.params[0].param) ? sheet.params[0].param : [sheet.params[0].param];
+            params.forEach((param, j) => {
+              if (param.$) {
+                const attrs = Object.keys(param.$);
+                const invalidAttrs = attrs.filter(attr => !allowedAttributes.param.includes(attr));
+                if (invalidAttrs.length > 0) {
+                  errors.push(`sheet #${i + 1}의 param element #${j + 1}의 허용되지 않는 속성: ${invalidAttrs.join(', ')}`);
+                }
+              }
+            });
+          }
+        });
+      }
+    }
+    
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
   /**
    * XML 파일에서 쿼리 로드
    * @param {string} xmlPath - XML 파일 경로
@@ -62,6 +197,16 @@ class QueryParser {
     const parsed = await xml2js.parseStringPromise(xml, { trim: true });
     if (!parsed.queries || !parsed.queries.sheet) throw new Error('Invalid XML format');
     
+    // XML 구조 검증
+    const structureValidation = this.validateXMLStructure(parsed);
+    if (!structureValidation.valid) {
+      console.error('\n❌ XML 구조 검증 실패:');
+      structureValidation.errors.forEach(error => {
+        console.error(`   - ${error}`);
+      });
+      throw new Error('XML 구조 검증 실패');
+    }
+    
     // 쿼리 정의 파싱
     let queryDefs = {};
     if (parsed.queries.queryDefs && parsed.queries.queryDefs[0] && parsed.queries.queryDefs[0].queryDef) {
@@ -70,16 +215,22 @@ class QueryParser {
           const queryName = queryDef.$.id || queryDef.$.name;
           const queryText = (queryDef._ || queryDef['#text'] || queryDef.__cdata || '').toString().trim();
           
+          console.log(`[DEBUG] queryDef 파싱: id="${queryName}", queryText 길이=${queryText.length}`);
+          
           if (queryText) {
             queryDefs[queryName] = {
               name: queryName,
               description: queryDef.$.description || '',
               query: queryText
             };
+            console.log(`[DEBUG] queryDef 추가됨: ${queryName}`);
+          } else {
+            console.warn(`[WARN] queryDef "${queryName}"의 쿼리 텍스트가 비어있습니다.`);
           }
         }
       }
     }
+    console.log(`[DEBUG] 총 ${Object.keys(queryDefs).length}개의 queryDef 로드됨: ${Object.keys(queryDefs).join(', ')}`);
     
     // 전역 변수 파싱
     let globalVars = {};
@@ -188,17 +339,6 @@ class QueryParser {
         }
       }
       
-      // 시트명 검증
-      const sheetNameValidation = this.validateSheetName(s.$.name, i);
-      if (!sheetNameValidation.valid) {
-        console.error(`\n❌ 시트명 검증 실패 (시트 #${i + 1}):`);
-        console.error(`   시트명: "${s.$.name}"`);
-        sheetNameValidation.errors.forEach(error => {
-          console.error(`   - ${error}`);
-        });
-        throw new Error(`시트명 검증 실패: "${s.$.name}"`);
-      }
-      
       // queryRef 속성이 있으면 쿼리 정의에서 참조
       if (s.$.queryRef) {
         const queryRef = s.$.queryRef;
@@ -257,17 +397,6 @@ class QueryParser {
       let query = sheet.query || '';
       let sheetParams = sheet.params || {};
       
-      // 시트명 검증
-      const sheetNameValidation = this.validateSheetName(sheet.name, i);
-      if (!sheetNameValidation.valid) {
-        console.error(`\n❌ 시트명 검증 실패 (시트 #${i + 1}):`);
-        console.error(`   시트명: "${sheet.name}"`);
-        sheetNameValidation.errors.forEach(error => {
-          console.error(`   - ${error}`);
-        });
-        throw new Error(`시트명 검증 실패: "${sheet.name}"`);
-      }
-      
       // queryRef가 있으면 쿼리 정의에서 참조
       if (sheet.queryRef) {
         if (queryDefs[sheet.queryRef]) {
