@axboot-mcp/mcp-server 1.0.0

package/scripts/generate-stores-v4.js

@@ -0,0 +1,521 @@
+/**
+ * StoreNew.ts 파일 생성 스크립트 v4 (타입 오류 수정)
+ * 리포지토리 파일을 분석하여 StoreNew.ts 파일 생성
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 경로 설정
+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';
+
+// 기본 템플릿 (Type 6: Simple List)
+const SIMPLE_LIST_TEMPLATE = `import { AXDGDataItem, AXDGPage, AXDGSortParam } from "@axboot/datagrid";
+import { pageStoreActions } from "@core/stores/pageStoreActions";
+import { StoreActions } from "@core/stores/types";
+import { PageStoreActions } from "@core/stores/types";
+import { deleteEmptyValue } from "@core/utils/object";
+import { ProgramFn } from "@types";
+{{IMPORTS}}
+import { getTabStoreListener } from "stores";
+import { create } from "zustand";
+import { subscribeWithSelector } from "zustand/middleware";
+import { shallow } from "zustand/shallow";
+
+interface ListRequest extends {{LIST_REQUEST}} {}
+
+interface DtoItem extends {{DTO_ITEM}} {}
+
+// ========== interface MetaData ==========
+interface MetaData {
+  programFn?: ProgramFn;
+  listRequestValue: ListRequest;
+  listColWidths: number[];
+  listSortParams: AXDGSortParam[];
+  listSelectedRowKey?: React.Key;
+}
+
+// ========== interface States ==========
+interface States extends MetaData {
+  routePath?: string;
+  listSpinning: boolean;
+  listData: AXDGDataItem<DtoItem>[];
+  listPage: AXDGPage;
+  selectedItem?: DtoItem;
+}
+
+// ========== const createState ==========
+const createState: States = {
+  listRequestValue: {{DEFAULT_REQUEST_VALUES}},
+  listColWidths: [],
+  listSpinning: false,
+  listData: [],
+  listPage: {
+    currentPage: 0,
+    totalPages: 0,
+  },
+  listSortParams: [],
+  selectedItem: undefined,
+};
+
+// ========== interface Actions ==========
+interface Actions extends PageStoreActions<States> {
+  setListRequestValue: (requestValue: ListRequest) => void;
+  setListColWidths: (colWidths: number[]) => void;
+  setListSortParams: (sortParams: AXDGSortParam[]) => void;
+  setListSpinning: (spinning: boolean) => void;
+  callListApi: (request?: ListRequest) => Promise<void>;
+  changeListPage: (currentPage: number, pageSize?: number) => Promise<void>;
+  setListSelectedRowKey: (key?: React.Key) => void;
+  setSelectedItem: (selectedItem?: DtoItem) => void;
+}
+
+// ========== const createActions ==========
+const createActions: StoreActions<States & Actions, Actions> = (set, get) => ({
+  ...pageStoreActions(set, get, { createState }),
+  syncMetadata: (s = createState) => set(s),
+  onMountApp: async () => {},
+
+  setListRequestValue: (requestValues) => set({ listRequestValue: requestValues }),
+  setListColWidths: (colWidths) => set({ listColWidths: colWidths }),
+  setListSortParams: (sortParams) => set({ listSortParams: sortParams }),
+
+  setListSpinning: (spinning) => set({ listSpinning: spinning }),
+
+  {{LIST_METHOD_COMMENT}}
+  callListApi: async (request) => {
+    if (get().listSpinning) return;
+    set({ listSpinning: true });
+
+    try {
+      const apiParam: ListRequest = { ...get().listRequestValue, ...request };
+      const response = await {{SERVICE_NAME}}.{{LIST_METHOD_NAME}}(deleteEmptyValue(apiParam));
+
+      set({
+        listRequestValue: apiParam,
+        listData: response.ds.map((values) => ({ values })),
+        listPage: {
+          currentPage: response.page.pageNumber ?? 1,
+          pageSize: response.page.pageSize ?? 0,
+          totalPages: response.page.pageCount ?? 0,
+          totalElements: response.page?.totalCount,
+        },
+      });
+    } finally {
+      set({ listSpinning: false });
+    }
+  },
+
+  changeListPage: async (pageNumber, pageSize) => {
+    await get().callListApi({ pageNumber, pageSize });
+  },
+
+  setListSelectedRowKey: (key) => set({ listSelectedRowKey: key }),
+
+  setSelectedItem: (selectedItem) => set({ selectedItem }),
+});
+
+// ========== export ==========
+export interface {{STORE_INTERFACE}} extends States, Actions, PageStoreActions<States> {}
+
+export const {{STORE_NAME}} = create(
+  subscribeWithSelector<{{STORE_INTERFACE}}>((set, get) => ({
+    ...createState,
+    ...createActions(set, get),
+  })),
+);
+
+// ========== Store.subscribe ==========
+{{STORE_NAME}}.subscribe(
+  (s): Record<keyof MetaData, any> => ({
+    programFn: s.programFn,
+    listRequestValue: s.listRequestValue,
+    listColWidths: s.listColWidths,
+    listSortParams: s.listSortParams,
+    listSelectedRowKey: s.listSelectedRowKey
+  }),
+  getTabStoreListener<MetaData>(createState.routePath),
+  { equalityFn: shallow },
+);
+`;
+
+/**
+ * 리포지토리 파일에서 정보 추출
+ */
+function analyzeRepository(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+
+  // 클래스 이름 추출
+  const classNameMatch = content.match(/export class (\w+)Repository/);
+  const className = classNameMatch ? classNameMatch[1] : '';
+
+  // Service 이름 추출 - Repository → Service (같은 패턴 유지)
+  const serviceName = className.replace('Repository', '') + 'Service';
+
+  // 인터페이스 추출
+  const interfaceMatch = content.match(/extends (\w+)Interface/);
+  const interfaceName = interfaceMatch ? interfaceMatch[1] : className;
+
+  // 메서드 추출
+  // imports 추출 및 메서드 분석 (중복 제거)
+  const importsSet = new Set();
+  const methods = [];
+  const methodBlocks = content.split(/async\s+/).slice(1);
+
+  // 기본 imports 추가 (배열 타입 제외, Interface 타입 제외)
+  const importMatch = content.match(/import\s*\{([^}]+)\}\s*from\s*"[\.\.\/]+interface"/);
+  if (importMatch) {
+    importMatch[1].split(',').forEach(item => {
+      const trimmed = item.trim();
+      // 배열 타입 제외 ([]로 끝나는 타입)
+      // Interface 타입 제외 (Interface로 끝나는 타입은 Store에서 불필요)
+      if (trimmed && !trimmed.endsWith('[]') && !trimmed.endsWith('Interface')) {
+        importsSet.add(trimmed);
+      }
+    });
+  }
+
+  // 메서드에서 사용되는 비배열 Response 타입도 추가
+  // (원본 import에 없는 타입만 추가)
+  methodBlocks.forEach(block => {
+    const apiWrapperMatch = block.match(/this\._apiWrapper<([^>]+)>/);
+    if (!apiWrapperMatch) return;
+
+    const returnType = apiWrapperMatch[1];
+
+    // Response 타입 추가 (배열 제외)
+    if (returnType && returnType !== 'void') {
+      // 배열 타입인 경우 비배열 버전 추가
+      if (returnType.endsWith('[]')) {
+        const nonArrayType = returnType.slice(0, -2);
+        if (!nonArrayType.endsWith('Interface')) {
+          importsSet.add(nonArrayType);
+        }
+      } else if (!returnType.endsWith('Interface')) {
+        importsSet.add(returnType);
+      }
+    }
+  });
+
+  // 메서드 추출 (주석 포함)
+  methodBlocks.forEach((block, index) => {
+    const methodNameMatch = block.match(/(\w+)\s*\(([^)]*)\)/);
+    if (!methodNameMatch) return;
+
+    const methodName = methodNameMatch[1];
+    const paramsStr = methodNameMatch[2];
+
+    // 파라미터 타입 추출 (배열 타입 제거)
+    let requestType = null;
+    const params = paramsStr.split(',').map(p => p.trim());
+    for (const p of params) {
+      if (p.includes(':') && p.includes('Request') && !p.includes('[]')) {
+        const type = p.split(':')[1]?.trim();
+        // 일반 타입 제외 (ApiRequestConfig 등)
+        if (type !== 'ApiRequestConfig' && type !== 'AxiosResponse') {
+          requestType = type;
+          break;
+        }
+      }
+    }
+
+    // _apiWrapper 호출에서 타입 추출
+    const apiWrapperMatch = block.match(/this\._apiWrapper<([^>]+)>/);
+    if (!apiWrapperMatch) return;
+
+    const returnType = apiWrapperMatch[1];
+
+    // Response 타입 추가 (배열 타입 제외)
+    if (returnType && returnType !== 'void' && !returnType.includes('[]')) {
+      importsSet.add(returnType);
+    }
+
+    // 엔드포인트 추출
+    const endpointMatch = block.match(/`([^`]+)`/);
+    const endpoint = endpointMatch ? endpointMatch[1] : '';
+
+    // 메서드 주석 추출 (원본 파일에서 /* 주석 */ 형태)
+    let comment = null;
+    // 정확한 메서드 이름 매칭을 위한 regex (단어 경계 사용)
+    const methodRegex = new RegExp(`async\\s+(${methodName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\s*\\(`);
+    const methodMatch = content.match(methodRegex);
+    if (methodMatch) {
+      const methodIndex = methodMatch.index;
+      // 메서드 바로 앞의 내용 추출
+      const contentBeforeMethod = content.substring(0, methodIndex).trim();
+      // 마지막 주석 찾기
+      const lastCommentStart = contentBeforeMethod.lastIndexOf('/*');
+      if (lastCommentStart !== -1) {
+        const lastCommentEnd = contentBeforeMethod.indexOf('*/', lastCommentStart);
+        if (lastCommentEnd !== -1) {
+          const commentCandidate = contentBeforeMethod.substring(lastCommentStart, lastCommentEnd + 2).trim();
+          // 주석과 메서드 사이의 내용 확인 (공백/줄바꿈만 허용)
+          const betweenCommentAndMethod = contentBeforeMethod.substring(lastCommentEnd + 2).trim();
+          // 주석 바로 다음에 이 메서드가 오는지 확인 (다른 async 키워드가 있으면 안 됨)
+          const nextAsyncIndex = betweenCommentAndMethod.lastIndexOf('async ');
+          if (nextAsyncIndex === -1 || betweenCommentAndMethod.substring(nextAsyncIndex + 6).trim().startsWith(methodName)) {
+            comment = commentCandidate;
+          }
+        }
+      }
+    }
+
+    methods.push({
+      name: methodName,
+      requestType,
+      returnType,
+      endpoint,
+      comment,
+    });
+  });
+
+  const imports = Array.from(importsSet);
+
+  return {
+    className,
+    serviceName,
+    interfaceName,
+    methods,
+    imports,
+  };
+}
+
+/**
+ * Service 이름 확인 (실제 프로젝트 기반)
+ */
+function getServiceName(repoClassName) {
+  // Repository → Service 변환 (같은 패턴)
+  return repoClassName.replace('Repository', '') + 'Service';
+}
+
+/**
+ * DTO 타입 이름 추정 - Repository 정보만 사용
+ */
+function guessDtoType(returnType, repoClassName, repoInfo) {
+  // List Response 타입을 그대로 사용 (가장 안전)
+  if (returnType && returnType !== 'void' && !returnType.includes('[]')) {
+    return returnType;
+  }
+
+  // fallback
+  return 'Record<string, any>';
+}
+
+/**
+ * 기존 Store 파일에서 Request 초기값 추출 (MCP 모드에서는 사용 안 함)
+ */
+function extractDefaultRequestValues(baseName) {
+  return '{\n    pageNumber: 1,\n    pageSize: 100,\n  }';
+}
+
+/**
+ * 템플릿 변수 생성
+ */
+function createTemplateVariables(repoInfo) {
+  const className = repoInfo.className;
+  const baseName = className.replace('Repository', '');
+
+  // LIST 메서드 찾기
+  const listMethod = repoInfo.methods.find(m =>
+    m.name.toLowerCase().includes('list') &&
+    !m.name.toLowerCase().includes('excel')
+  );
+
+  // LIST 메서드 주석 추출
+  const listMethodComment = listMethod?.comment || null;
+
+  // Request 타입 결정
+  let listRequestType = 'Partial<Record<string, any>>';
+  let defaultRequestValues = '{\n    pageNumber: 1,\n    pageSize: 100,\n  }';
+  let listResponseType = 'any';
+  let dtoItem = 'Record<string, any>';
+
+  if (listMethod) {
+    listResponseType = listMethod.returnType;
+
+    if (listMethod.requestType) {
+      listRequestType = listMethod.requestType;
+      // 기존 Store에서 초기값 추출
+      defaultRequestValues = extractDefaultRequestValues(baseName);
+    } else if (listResponseType.endsWith('Response')) {
+      listRequestType = listResponseType.replace('Response', 'Request');
+    }
+
+    // DTO 타입 추정
+    dtoItem = guessDtoType(listResponseType, className, repoInfo);
+  }
+
+  // imports 생성 - Repository의 import만 사용
+  const allImports = new Set(repoInfo.imports);
+
+  // 일반 타입 제거 (ApiRequestConfig 등)
+  const genericTypes = new Set(['ApiRequestConfig', 'AxiosResponse', 'Promise']);
+  genericTypes.forEach(type => allImports.delete(type));
+
+  // imports 정렬
+  const sortedImports = Array.from(allImports).sort();
+
+  // Service import 생성
+  const serviceName = getServiceName(className);
+  const importsLine = sortedImports.length > 0
+    ? `import { ${[...sortedImports, serviceName].join(', ')} } from "services";`
+    : `import { ${serviceName} } from "services";`;
+
+  // Store 이름 생성
+  const storeName = `use${baseName}Store`;
+  const storeInterface = `${baseName}Store`;
+
+  return {
+    STORE_NAME: storeName,
+    STORE_NAME_PASCAL: baseName,
+    STORE_INTERFACE: storeInterface,
+    SERVICE_NAME: getServiceName(className),
+    LIST_METHOD_NAME: listMethod?.name || 'getList',
+    LIST_REQUEST: listRequestType,
+    LIST_RESPONSE: listResponseType,
+    DTO_ITEM: dtoItem,
+    IMPORTS: importsLine,
+    DEFAULT_REQUEST_VALUES: defaultRequestValues,
+    LIST_METHOD_COMMENT: listMethodComment || '',
+  };
+}
+
+/**
+ * Store 파일 경로 결정 (Repository 이름으로만 결정 - 개선된 매칭)
+ */
+function determineStorePath(baseName) {
+  // 여러 단어로 구성된 이름을 dot-case로 변환 (폴더명은 dot 사용)
+  // 예: B2bEstimateConsulting → b2b.estimate.consulting
+  const dotName = baseName
+    .replace(/([a-z])([A-Z])/g, '$1.$2')
+    .replace(/^b2b\./i, 'b2b.')
+    .toLowerCase();
+
+  // NH 하위의 모든 디렉토리 검색
+  const dirs = fs.readdirSync(STORE_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  // 각 폴더별 매칭 점수 계산
+  const scoredDirs = dirs.map(dir => {
+    const dirLower = dir.toLowerCase();
+    let score = 0;
+
+    // 정확히 일치하면 최고 점수
+    if (dirLower === dotName) {
+      return { dir, score: 1000 };
+    }
+
+    // 단어별 정확한 일치 (dot과 hyphen 모두 지원)
+    const dirWords = dirLower.split(/[\.-]/);
+    const repoWords = dotName.split('.');
+    repoWords.forEach(repoWord => {
+      if (dirWords.includes(repoWord)) {
+        score += 10; // 단어 정확히 일치
+      }
+    });
+
+    // 부분 문자열 일치 (더 긴 쪽에 높은 점수)
+    if (dirLower.includes(dotName.replace(/\./g, '.'))) {
+      score += 5;
+    } else if (dotName.replace(/\./g, '').includes(dirLower.replace(/[\.-]/g, ''))) {
+      score += 3;
+    }
+
+    return { dir, score };
+  });
+
+  // 점수가 가장 높은 폴더 선택 (최소 10점 이상)
+  const bestMatch = scoredDirs.filter(d => d.score >= 10)
+    .sort((a, b) => b.score - a.score)[0];
+
+  if (bestMatch) {
+    return path.join(STORE_DIR, bestMatch.dir, `use${baseName}StoreNew.ts`);
+  }
+
+  // 매칭되는 폴더가 없으면 루트에 생성
+  return path.join(STORE_DIR, `use${baseName}StoreNew.ts`);
+}
+
+/**
+ * 템플릿 렌더링
+ */
+function renderTemplate(template, variables) {
+  let result = template;
+
+  Object.keys(variables).forEach(key => {
+    const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+    result = result.replace(regex, variables[key]);
+  });
+
+  return result;
+}
+
+/**
+ * 메인 실행 함수
+ */
+function main() {
+  console.log('=== StoreNew.ts 파일 생성 시작 v4 (타입 오류 수정) ===\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 || repoInfo.methods.length === 0) {
+        console.log(`[${index + 1}/${repoFiles.length}] SKIP: ${file} - 메서드를 찾을 수 없음`);
+        skipCount++;
+        return;
+      }
+
+      const baseName = repoInfo.className.replace('Repository', '');
+
+      // 템플릿 변수 생성
+      const variables = createTemplateVariables(repoInfo);
+
+      // 템플릿 렌더링
+      const rendered = renderTemplate(SIMPLE_LIST_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 생성 (${variables.LIST_METHOD_NAME})`);
+      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, createTemplateVariables, renderTemplate };