@axboot-mcp/mcp-server 1.0.0

package/scripts/generate-stores.js

@@ -0,0 +1,382 @@
+/**
+ * StoreNew.ts 파일 생성 스크립트
+ * 리포지토리 파일을 분석하여 StoreNew.ts 파일 생성
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { parse } = require('@typescript-eslint/typescript-estree');
+
+// 경로 설정
+const REPO_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/services/@interface/repository';
+const STORE_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/pages/resources/NH';
+const TEMPLATE_DIR = path.join(__dirname, '../src/templates');
+
+// 템플릿 가져오기
+const templates = {
+  type1: fs.readFileSync(path.join(TEMPLATE_DIR, 'type1.ts'), 'utf-8'),
+  type2: fs.readFileSync(path.join(TEMPLATE_DIR, 'type2.ts'), 'utf-8'),
+  type3: fs.readFileSync(path.join(TEMPLATE_DIR, 'type3.ts'), 'utf-8'),
+  type6: fs.readFileSync(path.join(TEMPLATE_DIR, 'type6.ts'), 'utf-8'),
+  type7: fs.readFileSync(path.join(TEMPLATE_DIR, 'type7.ts'), 'utf-8'),
+  type8: fs.readFileSync(path.join(TEMPLATE_DIR, 'type8.ts'), 'utf-8'),
+  type9: fs.readFileSync(path.join(TEMPLATE_DIR, 'type9.ts'), 'utf-8'),
+  type10: fs.readFileSync(path.join(TEMPLATE_DIR, 'type10.ts'), 'utf-8'),
+  type11: fs.readFileSync(path.join(TEMPLATE_DIR, 'type11.ts'), 'utf-8'),
+};
+
+/**
+ * 리포지토리 파일에서 정보 추출
+ */
+function analyzeRepository(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+
+  // 클래스 이름 추출
+  const classNameMatch = content.match(/export class (\w+)Repository/);
+  const className = classNameMatch ? classNameMatch[1] : '';
+
+  // Service 이름 추출 (ClassName에서 Repository 제거 + Service)
+  const serviceName = className.replace('Repository', '') + 'Service';
+
+  // 인터페이스 추출
+  const interfaceMatch = content.match(/extends (\w+)Interface/);
+  const interfaceName = interfaceMatch ? interfaceMatch[1] : '';
+
+  // 메서드 추출
+  const methodPattern = /async (\w+)\(([^)]*)\): Promise<([^>]+)>/g;
+  const methods = [];
+  let match;
+
+  while ((match = methodPattern.exec(content)) !== null) {
+    methods.push({
+      name: match[1],
+      params: match[2],
+      returnType: match[3],
+    });
+  }
+
+  // Request/Response 타입 추출
+  const importMatch = content.match(/import \{([^}]+)\} from "\.\.\/interface"/);
+  const imports = importMatch ? importMatch[1].split(',').map(s => s.trim()) : [];
+
+  const requestTypes = imports.filter(i => i.includes('Request'));
+  const responseTypes = imports.filter(i => i.includes('Response'));
+
+  return {
+    className,
+    serviceName,
+    interfaceName,
+    methods,
+    requestTypes,
+    responseTypes,
+    imports: importMatch ? importMatch[0] : '',
+  };
+}
+
+/**
+ * 스토어 타입 결정
+ */
+function determineStoreType(repoInfo) {
+  const methods = repoInfo.methods.map(m => m.name.toLowerCase());
+
+  // DELETE 메서드가 있는지 확인
+  const hasDelete = methods.some(m => m.includes('delete') || m.includes('remove'));
+
+  // SAVE 메서드가 있는지 확인
+  const hasSave = methods.some(m => m.includes('save') || m.includes('insert') || m.includes('update') || m.includes('create'));
+
+  // LIST 메서드가 있는지 확인
+  const hasList = methods.some(m => m.includes('list') || m.includes('find') || m.includes('get'));
+
+  // EXCEL 메서드가 있는지 확인
+  const hasExcel = methods.some(m => m.includes('excel') || m.includes('download'));
+
+  // DETAIL 메서드가 있는지 확인
+  const hasDetail = methods.some(m => m.includes('detail') || (m.includes('get') && !m.includes('list')));
+
+  // 메서드 개수에 따른 분류
+  const methodCount = methods.length;
+
+  // 타입 결정 로직
+  if (hasDelete && hasSave && hasList) {
+    return 2; // Master-Detail + Modal + Delete
+  } else if (hasSave && hasList) {
+    return 1; // Basic List + Detail
+  } else if (hasList) {
+    return 6; // Simple List
+  } else if (hasSave) {
+    return 5; // Simple (Save only)
+  }
+
+  return 6; // Default: Simple List
+}
+
+/**
+ * 템플릿 변수 생성
+ */
+function createTemplateVariables(repoInfo, storeType, existingStore) {
+  const className = repoInfo.className;
+  const baseName = className.replace('Repository', '');
+
+  // 기존 Store에서 패턴 추출
+  const existingPattern = existingStore ? analyzeExistingStore(existingStore) : null;
+
+  // LIST 메서드 찾기
+  const listMethod = repoInfo.methods.find(m =>
+    m.name.toLowerCase().includes('list') &&
+    !m.name.toLowerCase().includes('excel')
+  ) || repoInfo.methods[0];
+
+  // DELETE 메서드 찾기
+  const deleteMethod = repoInfo.methods.find(m =>
+    m.name.toLowerCase().includes('delete') ||
+    m.name.toLowerCase().includes('remove')
+  );
+
+  // SAVE 메서드 찾기
+  const saveMethod = repoInfo.methods.find(m =>
+    m.name.toLowerCase().includes('save') ||
+    m.name.toLowerCase().includes('insert') ||
+    m.name.toLowerCase().includes('update') ||
+    m.name.toLowerCase().includes('create')
+  );
+
+  // DETAIL 메서드 찾기
+  const detailMethod = repoInfo.methods.find(m =>
+    m.name.toLowerCase().includes('detail') ||
+    (m.name.toLowerCase().includes('get') && !m.name.toLowerCase().includes('list'))
+  );
+
+  // Request 타입 찾기
+  const listRequestType = listMethod ?
+    (listMethod.returnType.includes('Response') ?
+      listMethod.returnType.replace('Response', 'Request') :
+      `Post${baseName}${listMethod.name.charAt(0).toUpperCase() + listMethod.name.slice(1)}Request`) :
+    `${baseName}Request`;
+
+  // Response 타입 찾기
+  const listResponseType = listMethod ?
+    listMethod.returnType :
+    `${baseName}Response`;
+
+  // DTO 타입 추정
+  const dtoItem = listResponseType.replace('Response', 'Res') || `${baseName}Res`;
+
+  // 기존 Store의 초기값 패턴 추출
+  const defaultRequestValues = existingPattern?.defaultRequestValues || {
+    pageNumber: 1,
+    pageSize: 100,
+  };
+
+  // Store 이름 생성 (camelCase)
+  const storeName = `use${baseName}Store`;
+  const storeInterface = `${baseName}Store`;
+  const storeNamePascal = baseName;
+
+  return {
+    STORE_NAME: storeName,
+    STORE_NAME_PASCAL: storeNamePascal,
+    STORE_INTERFACE: storeInterface,
+    SERVICE_NAME: repoInfo.serviceName,
+    LIST_METHOD_NAME: listMethod?.name || 'getList',
+    DELETE_METHOD_NAME: deleteMethod?.name,
+    SAVE_METHOD_NAME: saveMethod?.name,
+    DETAIL_METHOD_NAME: detailMethod?.name,
+    DELETE_API_CALL: deleteMethod ? `await ${repoInfo.serviceName}.${deleteMethod.name}(id);` : '',
+    SAVE_API_CALL: saveMethod ? `await ${repoInfo.serviceName}.${saveMethod.name}(apiParam);` : '',
+    LIST_REQUEST: listRequestType,
+    LIST_RESPONSE: listResponseType,
+    DTO_ITEM: dtoItem,
+    DTO_ITEM_LOWER: dtoItem.charAt(0).toLowerCase() + dtoItem.slice(1),
+    HAS_PAGE: true,
+    HAS_SAVE: !!saveMethod,
+    HAS_DELETE: !!deleteMethod,
+    HAS_DETAIL: !!detailMethod,
+    HAS_LIST: true,
+    IMPORTS: repoInfo.imports,
+  };
+}
+
+/**
+ * 기존 Store 분석
+ */
+function analyzeExistingStore(content) {
+  // listRequestValue의 초기값 추출
+  const createStateMatch = content.match(/const createState: States = \{([^}]+)\}/s);
+  if (createStateMatch) {
+    const listRequestValueMatch = createStateMatch[1].match(/listRequestValue: \{([^}]+)\}/s);
+    if (listRequestValueMatch) {
+      // 기본값 파싱
+      const values = listRequestValueMatch[1].split(',').map(v => v.trim());
+      const defaultRequestValues = {};
+      values.forEach(v => {
+        const [key, ...valueParts] = v.split(':');
+        const value = valueParts.join(':').trim().replace(/,/g, '');
+        if (key && value) {
+          defaultRequestValues[key.trim()] = value;
+        }
+      });
+      return { defaultRequestValues };
+    }
+  }
+  return null;
+}
+
+/**
+ * 템플릿 렌더링
+ */
+function renderTemplate(template, variables) {
+  let result = template;
+
+  // Handlebars 스타일 치환
+  Object.keys(variables).forEach(key => {
+    const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+    const regexIf = new RegExp(`\\{\\{#${key}\\}\\}([\\s\\S]*?)\\{\\{/${key}\\}\\}`, 'g');
+    const regexIfNot = new RegExp(`\\{\\{\\^${key}\\}\\}([\\s\\S]*?)\\{\\{/${key}\\}\\}`, 'g');
+
+    if (variables[key]) {
+      // 조건부 치환 처리
+      result = result.replace(regexIf, (match, content) => content);
+      result = result.replace(regexIfNot, '');
+      result = result.replace(regex, variables[key]);
+    } else {
+      result = result.replace(regexIf, '');
+      result = result.replace(regexIfNot, (match, content) => content);
+      result = result.replace(regex, '');
+    }
+  });
+
+  return result;
+}
+
+/**
+ * 기존 Store 파일 찾기
+ */
+function findExistingStore(baseName) {
+  // 가능한 Store 파일 경로들
+  const possiblePaths = [
+    path.join(STORE_DIR, `${kebabCase(baseName)}.use${baseName}Store.ts`),
+    path.join(STORE_DIR, `${kebabCase(baseName)}/use${baseName}Store.ts`),
+  ];
+
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      return fs.readFileSync(p, 'utf-8');
+    }
+  }
+
+  return null;
+}
+
+/**
+ * camelCase를 kebab-case로 변환
+ */
+function kebabCase(str) {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase();
+}
+
+/**
+ * Store 파일 경로 결정
+ */
+function determineStorePath(baseName) {
+  // 기존 파일 구조 확인
+  const possibleDirs = [
+    path.join(STORE_DIR, `${kebabCase(baseName)}`),
+    STORE_DIR,
+  ];
+
+  for (const dir of possibleDirs) {
+    if (fs.existsSync(dir)) {
+      return path.join(dir, `use${baseName}StoreNew.ts`);
+    }
+  }
+
+  // 기본 경로
+  return path.join(STORE_DIR, `use${baseName}StoreNew.ts`);
+}
+
+/**
+ * 메인 실행 함수
+ */
+function main() {
+  console.log('=== StoreNew.ts 파일 생성 시작 ===\n');
+
+  // 리포지토리 파일 목록 가져오기
+  const repoFiles = fs.readdirSync(REPO_DIR)
+    .filter(file => file.endsWith('Repository.ts') && file !== 'APIRepository.ts');
+
+  console.log(`리포지토리 파일 ${repoFiles.length}개 발견\n`);
+
+  let successCount = 0;
+  let skipCount = 0;
+  let errorCount = 0;
+
+  repoFiles.forEach((file, index) => {
+    try {
+      const repoPath = path.join(REPO_DIR, file);
+      const repoInfo = analyzeRepository(repoPath);
+
+      if (!repoInfo.className) {
+        console.log(`[${index + 1}/${repoFiles.length}] SKIP: ${file} - 클래스를 찾을 수 없음`);
+        skipCount++;
+        return;
+      }
+
+      const baseName = repoInfo.className.replace('Repository', '');
+      const storeType = determineStoreType(repoInfo);
+
+      // 기존 Store 파일 찾기
+      const existingStore = findExistingStore(baseName);
+
+      // 템플릿 변수 생성
+      const variables = createTemplateVariables(repoInfo, storeType, existingStore);
+
+      // 템플릿 선택
+      const templateKey = `type${storeType}`;
+      const template = templates[templateKey];
+
+      if (!template) {
+        console.log(`[${index + 1}/${repoFiles.length}] SKIP: ${file} - 템플릿을 찾을 수 없음 (Type ${storeType})`);
+        skipCount++;
+        return;
+      }
+
+      // 템플릿 렌더링
+      const rendered = renderTemplate(template, variables);
+
+      // 출력 경로 결정
+      const outputPath = determineStorePath(baseName);
+
+      // 디렉토리 생성
+      const outputDir = path.dirname(outputPath);
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+
+      // 파일 쓰기
+      fs.writeFileSync(outputPath, rendered);
+
+      console.log(`[${index + 1}/${repoFiles.length}] SUCCESS: ${baseName}StoreNew.ts 생성 (Type ${storeType})`);
+      successCount++;
+
+    } catch (error) {
+      console.error(`[${index + 1}/${repoFiles.length}] ERROR: ${file} - ${error.message}`);
+      errorCount++;
+    }
+  });
+
+  console.log(`\n=== 생성 완료 ===`);
+  console.log(`성공: ${successCount}`);
+  console.log(`건너뜀: ${skipCount}`);
+  console.log(`오류: ${errorCount}`);
+}
+
+// 실행
+if (require.main === module) {
+  main();
+}
+
+module.exports = { analyzeRepository, determineStoreType, createTemplateVariables, renderTemplate };