@axboot-mcp/mcp-server 1.0.0

package/scripts/generate-stores-v2.js

@@ -0,0 +1,450 @@
+/**
+ * StoreNew.ts 파일 생성 스크립트 (수정본)
+ * 리포지토리 파일을 분석하여 StoreNew.ts 파일 생성
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 경로 설정
+const REPO_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/services/@interface/repository';
+const INTERFACE_DIR = '/Users/kyle/Desktop/nh-fe-bo/src/services/@interface';
+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: {
+    pageNumber: 1,
+    pageSize: 100,
+  },
+  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 }),
+
+  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 이름 추출 (ClassName에서 Repository 제거 + Service)
+  const serviceName = className.replace('Repository', '') + 'Service';
+
+  // 인터페이스 추출
+  const interfaceMatch = content.match(/extends (\w+)Interface/);
+  const interfaceName = interfaceMatch ? interfaceMatch[1] : className;
+
+  // 메서드 추출 (여러 줄에 걸친 패턴 처리)
+  const methodPattern = /async (\w+)\(([^)]*)\)[\s\S]*?this\._apiWrapper<([^>]+)>\s*\(\s*"([^"]*)"\s*,/g;
+  const methods = [];
+  let match;
+
+  while ((match = methodPattern.exec(content)) !== null) {
+    methods.push({
+      name: match[1],
+      params: match[2],
+      returnType: match[3],
+      httpMethod: match[4],
+      endpoint: match[5],
+    });
+  }
+
+  // Request/Response 타입 추출 (imports에서)
+  const imports = [];
+  const importPattern = /import \{([^}]+)\} from "\.\.\/interface"/g;
+  while ((match = importPattern.exec(content)) !== null) {
+    imports.push(match[1]);
+  }
+
+  return {
+    className,
+    serviceName,
+    interfaceName,
+    methods,
+    imports,
+  };
+}
+
+/**
+ * 인터페이스 파일에서 타입 정보 추출
+ */
+function analyzeInterfaceFiles() {
+  const interfaceTypes = {};
+
+  // interface 디렉토리의 모든 파일 스캔
+  const interfaceFiles = fs.readdirSync(INTERFACE_DIR)
+    .filter(file => file.endsWith('.ts') && file !== 'index.ts');
+
+  interfaceFiles.forEach(file => {
+    const content = fs.readFileSync(path.join(INTERFACE_DIR, file), 'utf-8');
+
+    // Request 타입 추출
+    const requestPattern = /export (interface|type) (\w+Request)/g;
+    let match;
+    while ((match = requestPattern.exec(content)) !== null) {
+      interfaceTypes[match[2]] = match[2];
+    }
+
+    // Response 타입 추출
+    const responsePattern = /export (interface|type) (\w+Response)/g;
+    while ((match = responsePattern.exec(content)) !== null) {
+      interfaceTypes[match[2]] = match[2];
+    }
+
+    // Res 타입 추출 (DTO)
+    const resPattern = /export (interface|type) (\w+Res)/g;
+    while ((match = resPattern.exec(content)) !== null) {
+      interfaceTypes[match[2]] = match[2];
+    }
+  });
+
+  return interfaceTypes;
+}
+
+/**
+ * 기존 Store 파일 찾기
+ */
+function findExistingStore(baseName) {
+  // kebab-case 변환
+  const kebabName = baseName
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .toLowerCase();
+
+  // 가능한 경로들
+  const possiblePaths = [
+    path.join(STORE_DIR, `${kebabName}.use${baseName}Store.ts`),
+    path.join(STORE_DIR, `use${baseName}Store.ts`),
+  ];
+
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      return fs.readFileSync(p, 'utf-8');
+    }
+  }
+
+  // 하위 디렉토리 검색
+  const dirs = fs.readdirSync(STORE_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  for (const dir of dirs) {
+    const filePath = path.join(STORE_DIR, dir, `use${baseName}Store.ts`);
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, 'utf-8');
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 템플릿 변수 생성
+ */
+function createTemplateVariables(repoInfo, interfaceTypes) {
+  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')
+  );
+
+  // Request 타입 결정
+  let listRequestType = 'any';
+  let listResponseType = 'any';
+  let dtoItem = `${baseName}Res`;
+
+  if (listMethod) {
+    // 메서드 반환 타입에서 Request/Response 추출
+    const returnType = listMethod.returnType;
+    listResponseType = returnType;
+
+    // Request 타입 추정
+    if (returnType.endsWith('Response')) {
+      listRequestType = returnType.replace('Response', 'Request');
+    } else {
+      listRequestType = `Post${baseName}${listMethod.name.charAt(0).toUpperCase() + listMethod.name.slice(1)}Request`;
+    }
+
+    // DTO 타입 추정
+    if (returnType.endsWith('Response')) {
+      dtoItem = returnType.replace('Response', 'Res');
+    } else if (returnType.endsWith('Res')) {
+      dtoItem = returnType;
+    } else {
+      dtoItem = `${baseName}Res`;
+    }
+  }
+
+  // imports 생성
+  const importsSet = new Set();
+  repoInfo.imports.forEach(imp => {
+    imp.split(',').forEach(item => {
+      const trimmed = item.trim();
+      if (trimmed) {
+        importsSet.add(trimmed);
+      }
+    });
+  });
+
+  const imports = `import { ${Array.from(importsSet).join(', ')} } 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: repoInfo.serviceName,
+    LIST_METHOD_NAME: listMethod?.name || 'getList',
+    LIST_REQUEST: listRequestType,
+    LIST_RESPONSE: listResponseType,
+    DTO_ITEM: dtoItem,
+    IMPORTS: imports,
+  };
+}
+
+/**
+ * Store 파일 경로 결정
+ */
+function determineStorePath(baseName) {
+  const kebabName = baseName
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .toLowerCase();
+
+  // 하위 디렉토리 검색
+  const dirs = fs.readdirSync(STORE_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  // 일치하는 디렉토리 찾기
+  const matchingDir = dirs.find(dir => {
+    const dirLower = dir.toLowerCase().replace(/-/g, '');
+    const nameLower = baseName.toLowerCase();
+    return dirLower.includes(nameLower) || nameLower.includes(dirLower.replace(/[^a-z]/g, ''));
+  });
+
+  if (matchingDir) {
+    return path.join(STORE_DIR, matchingDir, `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 파일 생성 시작 v2 ===\n');
+
+  // 인터페이스 타입 분석
+  const interfaceTypes = analyzeInterfaceFiles();
+  console.log(`인터페이스 타입 ${Object.keys(interfaceTypes).length}개 발견\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, interfaceTypes);
+
+      // 템플릿 렌더링
+      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 생성`);
+      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 };