mock-fried 1.0.0

package/dist/runtime/server/utils/client-parser.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedClientPackage, OpenApiClientConfig } from '../../../types.js';
+/**
+ * 클라이언트 패키지 전체 파싱
+ */
+export declare function parseClientPackage(packageRoot: string, config?: Partial<OpenApiClientConfig>): ParsedClientPackage;
+/**
+ * 클라이언트 패키지 파싱 (캐시 지원)
+ */
+export declare function getClientPackage(packageRoot: string, config?: Partial<OpenApiClientConfig>): ParsedClientPackage;
+/**
+ * 캐시 초기화
+ */
+export declare function clearClientPackageCache(): void;

package/dist/runtime/server/utils/client-parser.js

@@ -0,0 +1,272 @@
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { resolve, join } from "pathe";
+function parseApiFile(filePath, fileName) {
+  const content = readFileSync(filePath, "utf-8");
+  const endpoints = [];
+  const classMatch = content.match(/export class (\w+Api)/);
+  const apiClassName = classMatch?.[1] || fileName.replace(".ts", "");
+  const rawMethodRegex = /\/\*\*([\s\S]*?)\*\/\s*\n\s*async\s+(\w+)Raw\([^)]*\):\s*Promise<runtime\.ApiResponse<((?:[^<>]|<[^>]*>)+)>>/g;
+  const methodBodyRegex = /async\s+(\w+)Raw\([^{]+\{([\s\S]*?)return new runtime\./g;
+  let match;
+  const methodBodies = /* @__PURE__ */ new Map();
+  while ((match = methodBodyRegex.exec(content)) !== null) {
+    const methodName = match[1];
+    const body = match[2];
+    methodBodies.set(methodName, body);
+  }
+  rawMethodRegex.lastIndex = 0;
+  while ((match = rawMethodRegex.exec(content)) !== null) {
+    const jsdocContent = match[1];
+    const operationId = match[2];
+    const responseType = match[3];
+    const jsdocLines = jsdocContent.split("\n").map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter((line) => line.length > 0 && !line.startsWith("@"));
+    const summary = jsdocLines[jsdocLines.length - 1] || jsdocLines[0] || operationId;
+    const body = methodBodies.get(operationId);
+    if (!body) continue;
+    const pathMatch = body.match(/path:\s*`([^`]+)`/);
+    if (!pathMatch) continue;
+    let path = pathMatch[1];
+    path = path.replace(/\$\{[^}]+\}/g, (match2) => {
+      const paramName = match2.match(/\["?(\w+)"?\]/)?.[1] || "param";
+      return `{${paramName}}`;
+    });
+    const methodMatch = body.match(/method:\s*'(\w+)'/);
+    const method = methodMatch?.[1] || "GET";
+    const pathParams = [];
+    const pathParamMatches = path.matchAll(/\{(\w+)\}/g);
+    for (const pm of pathParamMatches) {
+      pathParams.push({
+        name: pm[1],
+        type: "string",
+        required: true
+      });
+    }
+    const queryParams = [];
+    const queryParamRegex = /if\s*\(requestParameters\.(\w+)\s*!==\s*undefined\)\s*\{\s*queryParameters\['(\w+)'\]/g;
+    let qpm;
+    while ((qpm = queryParamRegex.exec(body)) !== null) {
+      queryParams.push({
+        name: qpm[2],
+        type: "string",
+        required: false
+      });
+    }
+    let requestBodyType;
+    const bodyMatch = body.match(/body:\s*(\w+)ToJSON\(requestParameters\.(\w+)\)/);
+    if (bodyMatch) {
+      requestBodyType = bodyMatch[1];
+    }
+    endpoints.push({
+      path,
+      method: method.toUpperCase(),
+      operationId,
+      summary,
+      apiClassName,
+      pathParams,
+      queryParams,
+      requestBodyType,
+      responseType
+    });
+  }
+  return endpoints;
+}
+function analyzeType(rawType) {
+  const primitives = ["string", "number", "boolean", "Date", "object", "any", "unknown", "void", "null", "undefined"];
+  const isArray = rawType.startsWith("Array<") || rawType.endsWith("[]");
+  let type = rawType;
+  if (isArray) {
+    const arrayTypeMatch = rawType.match(/Array<(.+)>/) || rawType.match(/(.+)\[\]/);
+    if (arrayTypeMatch) {
+      type = arrayTypeMatch[1].trim();
+    }
+  }
+  let refType;
+  if (!primitives.includes(type) && !type.includes("|") && !type.includes("&")) {
+    refType = type;
+  }
+  return { type, isArray, refType };
+}
+function parseModelFile(filePath, fileName) {
+  const content = readFileSync(filePath, "utf-8");
+  const modelName = fileName.replace(".ts", "");
+  const hasInterface = content.includes(`export interface ${modelName}`);
+  if (!hasInterface) {
+    const enumRegex = new RegExp(`export\\s+const\\s+(${modelName})\\s*=\\s*\\{([^}]+)\\}\\s*as\\s*const`);
+    const enumMatch = content.match(enumRegex);
+    if (enumMatch) {
+      const enumValues = [];
+      const valueMatches = enumMatch[2].matchAll(/(\w+):\s*['"]([^'"]+)['"]/g);
+      for (const vm of valueMatches) {
+        enumValues.push(vm[2]);
+      }
+      if (enumValues.length > 0) {
+        return {
+          name: modelName,
+          fields: [],
+          enumValues
+        };
+      }
+    }
+  }
+  const fields = [];
+  const jsonKeyMap = /* @__PURE__ */ new Map();
+  const toJsonMatch = content.match(/export\s+function\s+\w+ToJSON[^{]*\{[\s\S]*?return\s*\{([\s\S]*?)\};?\s*\}/);
+  if (toJsonMatch) {
+    const returnBody = toJsonMatch[1];
+    const fieldMatches = returnBody.matchAll(/['"](\w+)['"]\s*:\s*(?:value\.(\w+)|[^,\n]*?value\.(\w+))/g);
+    for (const fm of fieldMatches) {
+      const jsonKey = fm[1];
+      const propertyName = fm[2] || fm[3];
+      if (!propertyName) continue;
+      jsonKeyMap.set(propertyName, jsonKey);
+      if (fields.some((f) => f.name === propertyName)) continue;
+      fields.push({
+        name: propertyName,
+        jsonKey: jsonKey !== propertyName ? jsonKey : void 0,
+        type: "unknown",
+        // ToJSON에서는 타입을 알 수 없음, 나중에 interface에서 보완
+        required: false,
+        isArray: false
+      });
+    }
+  }
+  const fromJsonMatch = content.match(/export\s+function\s+\w+FromJSONTyped[^{]*\{[\s\S]*?return\s*\{([\s\S]*?)\};?\s*\}/);
+  if (fromJsonMatch) {
+    const returnBody = fromJsonMatch[1];
+    const dateFields = /* @__PURE__ */ new Set();
+    const dateMatches = returnBody.matchAll(/['"](\w+)['"]\s*:.*?new\s+Date\(/g);
+    for (const dm of dateMatches) {
+      dateFields.add(dm[1]);
+    }
+    const arrayFields = /* @__PURE__ */ new Set();
+    const arrayMatches = returnBody.matchAll(/['"](\w+)['"]\s*:.*?\(json\[['"](\w+)['"]\]\s*as\s*Array/g);
+    for (const am of arrayMatches) {
+      arrayFields.add(am[1]);
+    }
+    const refTypeMap = /* @__PURE__ */ new Map();
+    const refMatches = returnBody.matchAll(/['"](\w+)['"]\s*:.*?(\w+)FromJSON\(json\[/g);
+    for (const rm of refMatches) {
+      if (!rm[2].includes("Array")) {
+        refTypeMap.set(rm[1], rm[2]);
+      }
+    }
+    const arrayRefMatches = returnBody.matchAll(/['"](\w+)['"]\s*:.*?\.map\((\w+)FromJSON\)/g);
+    for (const arm of arrayRefMatches) {
+      refTypeMap.set(arm[1], arm[2]);
+      arrayFields.add(arm[1]);
+    }
+    for (const field of fields) {
+      if (dateFields.has(field.name)) {
+        field.type = "Date";
+      }
+      if (arrayFields.has(field.name)) {
+        field.isArray = true;
+      }
+      const refType = refTypeMap.get(field.name);
+      if (refType) {
+        field.refType = refType;
+        field.type = refType;
+      }
+    }
+  }
+  const interfaceMatch = content.match(/export\s+interface\s+(\w+)(?:\s+extends\s+[\w,\s]+)?\s*\{([\s\S]*?)\n\}/);
+  if (interfaceMatch) {
+    const interfaceBody = interfaceMatch[2];
+    const simpleFieldRegex = /^\s+(\w+)(\?)?:\s*([^;]+);/gm;
+    let sfm;
+    while ((sfm = simpleFieldRegex.exec(interfaceBody)) !== null) {
+      const name = sfm[1];
+      const optional = sfm[2] === "?";
+      const rawType = sfm[3].trim();
+      const { type, isArray, refType } = analyzeType(rawType);
+      const existingField = fields.find((f) => f.name === name);
+      if (existingField) {
+        if (existingField.type === "unknown") {
+          existingField.type = type;
+        }
+        existingField.required = !optional;
+        if (!existingField.isArray) {
+          existingField.isArray = isArray;
+        }
+        if (!existingField.refType && refType) {
+          existingField.refType = refType;
+        }
+      } else {
+        const jsonKey = jsonKeyMap.get(name);
+        fields.push({
+          name,
+          jsonKey: jsonKey && jsonKey !== name ? jsonKey : void 0,
+          type,
+          required: !optional,
+          isArray,
+          refType
+        });
+      }
+    }
+  }
+  if (fields.length === 0) {
+    return void 0;
+  }
+  return {
+    name: modelName,
+    fields
+  };
+}
+export function parseClientPackage(packageRoot, config) {
+  const apisDir = config?.apisDir || "src/apis";
+  const modelsDir = config?.modelsDir || "src/models";
+  const apisPath = resolve(packageRoot, apisDir);
+  const modelsPath = resolve(packageRoot, modelsDir);
+  const pkgJsonPath = join(packageRoot, "package.json");
+  let pkgInfo = { name: "unknown", title: void 0, version: void 0 };
+  if (existsSync(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      pkgInfo = {
+        name: pkgJson.name || "unknown",
+        title: pkgJson.description,
+        version: pkgJson.version
+      };
+    } catch {
+    }
+  }
+  const endpoints = [];
+  if (existsSync(apisPath)) {
+    const apiFiles = readdirSync(apisPath).filter((f) => f.endsWith("Api.ts") && f !== "index.ts");
+    for (const file of apiFiles) {
+      const filePath = join(apisPath, file);
+      const parsed = parseApiFile(filePath, file);
+      endpoints.push(...parsed);
+    }
+  }
+  const models = /* @__PURE__ */ new Map();
+  if (existsSync(modelsPath)) {
+    const modelFiles = readdirSync(modelsPath).filter((f) => f.endsWith(".ts") && f !== "index.ts");
+    for (const file of modelFiles) {
+      const filePath = join(modelsPath, file);
+      const parsed = parseModelFile(filePath, file);
+      if (parsed) {
+        models.set(parsed.name, parsed);
+      }
+    }
+  }
+  return {
+    info: pkgInfo,
+    endpoints,
+    models
+  };
+}
+let cachedPackage = null;
+let cachedPackagePath = null;
+export function getClientPackage(packageRoot, config) {
+  if (cachedPackage && cachedPackagePath === packageRoot) {
+    return cachedPackage;
+  }
+  cachedPackage = parseClientPackage(packageRoot, config);
+  cachedPackagePath = packageRoot;
+  return cachedPackage;
+}
+export function clearClientPackageCache() {
+  cachedPackage = null;
+  cachedPackagePath = null;
+}

package/dist/runtime/server/utils/mock/client-generator.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Client Package Mock 데이터 생성기
+ * OpenAPI Generator로 생성된 TypeScript 클라이언트 패키지 기반 Mock 생성
+ */
+import type { ParsedModelSchema, MockIdConfig } from '../../../../types.js';
+import { hashString, SeededRandom } from './shared.js';
+/**
+ * 필드명 기반 Mock 값 추론
+ */
+export declare function inferValueByFieldName(fieldName: string, rng: SeededRandom, index?: number, idConfig?: MockIdConfig): unknown;
+/**
+ * TypeScript 타입에 따른 기본값 생성
+ */
+export declare function generateValueByType(type: string, fieldName: string, rng: SeededRandom, index?: number, idConfig?: MockIdConfig): unknown;
+/**
+ * 필드명에서 타입을 추측하여 적절한 값 생성
+ */
+export declare function inferTypeFromFieldName(fieldName: string, rng: SeededRandom, index: number, idConfig?: MockIdConfig): unknown;
+/**
+ * 응답 타입 분석 결과
+ */
+export interface ResponseTypeInfo {
+    /** 실제 데이터 모델명 */
+    modelName: string;
+    /** 리스트 응답 여부 */
+    isList: boolean;
+    /** 배열 필드명 (posts, items, comments 등) - 응답 구조 생성시 사용 */
+    listFieldName?: string;
+    /** 래퍼 응답 타입인 경우 원본 타입명 */
+    wrapperType?: string;
+}
+/**
+ * 응답 타입에서 실제 데이터 모델명 추출
+ * 다양한 배열 필드명을 지원 (items, data, posts, comments 등)
+ */
+export declare function extractDataModelName(responseType: string, models: Map<string, ParsedModelSchema>): ResponseTypeInfo;
+/**
+ * 스키마 기반 Mock 데이터 생성기 클래스
+ */
+export declare class SchemaMockGenerator {
+    private models;
+    private dataStore;
+    private idConfig;
+    constructor(models: Map<string, ParsedModelSchema>, idConfig?: MockIdConfig);
+    /**
+     * 모델 스키마 기반 단일 객체 생성
+     */
+    generateOne(modelName: string, seed?: string | number, index?: number): Record<string, unknown>;
+    /**
+     * ID 부여된 단일 객체 생성 (Pagination용)
+     * 주어진 ID를 모델의 ID 필드에 설정하여 cursor와 응답 ID가 일치하도록 함
+     */
+    generateOneWithId(modelName: string, itemId: string, seed?: string | number, index?: number): Record<string, unknown>;
+    /**
+     * 모델의 ID 필드명 찾기 (MockIdConfig 기반)
+     */
+    private findIdFieldName;
+    /**
+     * 필드의 출력 키 가져오기 (jsonKey 또는 name)
+     */
+    private getOutputKey;
+    /**
+     * 필드 값 생성
+     */
+    private generateField;
+    /**
+     * 리스트 데이터 생성 (캐시 지원 - Pagination)
+     * @deprecated Use pagination/page-manager.ts instead for enhanced pagination
+     */
+    generateList(modelName: string, options?: {
+        page?: number;
+        limit?: number;
+        total?: number;
+        seed?: string;
+    }): {
+        items: Record<string, unknown>[];
+        pagination: {
+            page: number;
+            limit: number;
+            total: number;
+            totalPages: number;
+        };
+    };
+    /**
+     * 커서 기반 리스트 생성 (무한 스크롤용)
+     * @deprecated Use pagination/cursor-manager.ts instead for enhanced pagination
+     */
+    generateCursorList(modelName: string, options?: {
+        cursor?: string;
+        limit?: number;
+        total?: number;
+        seed?: string;
+    }): {
+        items: Record<string, unknown>[];
+        nextCursor?: string;
+        prevCursor?: string;
+        hasMore: boolean;
+    };
+    /**
+     * 모델 가져오기
+     */
+    getModels(): Map<string, ParsedModelSchema>;
+    /**
+     * 캐시 초기화
+     */
+    clearCache(): void;
+}
+export { SeededRandom, hashString };