mock-fried 1.0.7 → 1.1.1

package/README.md

@@ -346,8 +346,11 @@ yarn lint:fix
 yarn format
 
 # Run tests
-yarn test
-yarn test:watch
+yarn test              # All tests
+yarn test:unit         # Unit tests only
+yarn test:e2e          # E2E tests only
+yarn test:coverage     # With coverage report
+yarn test:watch        # Watch mode
 
 # Type check
 yarn test:types

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "1.0.7",
+  "version": "1.1.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/components/ApiExplorer.vue

@@ -88,6 +88,8 @@
 </template>
 
 <script setup>
+import { ref, onMounted } from "vue";
+import { useNuxtApp } from "#imports";
 import EndpointCard from "./EndpointCard.vue";
 import RpcMethodCard from "./RpcMethodCard.vue";
 import ResponseViewer from "./ResponseViewer.vue";

package/dist/runtime/components/EndpointCard.vue

@@ -112,6 +112,7 @@
 </template>
 
 <script setup>
+import { ref, computed } from "vue";
 const props = defineProps({
   endpoint: { type: Object, required: true },
   type: { type: String, required: true }

package/dist/runtime/components/ResponseViewer.vue

@@ -46,6 +46,7 @@
 </template>
 
 <script setup>
+import { ref, computed } from "vue";
 const props = defineProps({
   response: { type: Object, required: true }
 });

package/dist/runtime/components/RpcMethodCard.vue

@@ -64,6 +64,7 @@
 </template>
 
 <script setup>
+import { ref, watch } from "vue";
 const props = defineProps({
   service: { type: String, required: true },
   method: { type: Object, required: true }

package/dist/runtime/server/handlers/rpc.js

@@ -85,12 +85,148 @@ export function clearProtoCache() {
   protoCursorManager = null;
   protoPageManager = null;
 }
-function getResponseTypeInfo(methodDef) {
-  const responseType = methodDef.responseType;
-  if (responseType?.type) {
-    return responseType.type;
+const PROTO_TYPE_MAP = {
+  // 숫자 키 (legacy/fallback)
+  1: "double",
+  2: "float",
+  3: "int64",
+  4: "uint64",
+  5: "int32",
+  6: "fixed64",
+  7: "fixed32",
+  8: "bool",
+  9: "string",
+  10: "group",
+  11: "message",
+  12: "bytes",
+  13: "uint32",
+  14: "enum",
+  15: "sfixed32",
+  16: "sfixed64",
+  17: "sint32",
+  18: "sint64",
+  // 문자열 키 (proto-loader 실제 반환값)
+  TYPE_DOUBLE: "double",
+  TYPE_FLOAT: "float",
+  TYPE_INT64: "int64",
+  TYPE_UINT64: "uint64",
+  TYPE_INT32: "int32",
+  TYPE_FIXED64: "fixed64",
+  TYPE_FIXED32: "fixed32",
+  TYPE_BOOL: "bool",
+  TYPE_STRING: "string",
+  TYPE_GROUP: "group",
+  TYPE_MESSAGE: "message",
+  TYPE_BYTES: "bytes",
+  TYPE_UINT32: "uint32",
+  TYPE_ENUM: "enum",
+  TYPE_SFIXED32: "sfixed32",
+  TYPE_SFIXED64: "sfixed64",
+  TYPE_SINT32: "sint32",
+  TYPE_SINT64: "sint64"
+};
+function findTypeInPackageDefinition(typeName, packageDefinition) {
+  const cleanName = typeName.startsWith(".") ? typeName.slice(1) : typeName;
+  const directMatch = packageDefinition[cleanName];
+  if (directMatch?.type) {
+    return directMatch.type;
   }
-  return {};
+  if (!cleanName.includes(".")) {
+    for (const key of Object.keys(packageDefinition)) {
+      if (key.endsWith(`.${cleanName}`)) {
+        const matchedType = packageDefinition[key];
+        if (matchedType?.type) {
+          return matchedType.type;
+        }
+      }
+    }
+  }
+  return null;
+}
+function convertFieldDescriptor(fieldDesc, protoType, context) {
+  const typeName = PROTO_TYPE_MAP[fieldDesc.type] || "string";
+  const isRepeated = fieldDesc.label === 3 || fieldDesc.label === "LABEL_REPEATED";
+  const result = {
+    type: typeName,
+    rule: isRepeated ? "repeated" : void 0
+  };
+  if (fieldDesc.typeName) {
+    const shortName = fieldDesc.typeName.split(".").pop() || fieldDesc.typeName;
+    result.typeName = shortName;
+    if (context.depth >= context.maxDepth) {
+      return result;
+    }
+    const enumType = protoType.enumType?.find(
+      (e) => e.name === shortName
+    );
+    if (enumType) {
+      result.resolvedType = {
+        values: enumType.value?.reduce((acc, v) => {
+          acc[v.name] = v.number;
+          return acc;
+        }, {})
+      };
+      return result;
+    }
+    const nestedType = protoType.nestedType?.find(
+      (t) => t.name === shortName
+    );
+    if (nestedType) {
+      const nestedContext = {
+        ...context,
+        depth: context.depth + 1,
+        visitedTypes: /* @__PURE__ */ new Set([...context.visitedTypes, fieldDesc.typeName])
+      };
+      result.resolvedType = resolveProtoType(nestedType, nestedContext);
+      return result;
+    }
+    const externalType = findTypeInPackageDefinition(fieldDesc.typeName, context.packageDefinition);
+    if (externalType) {
+      const externalContext = {
+        ...context,
+        depth: context.depth + 1,
+        visitedTypes: /* @__PURE__ */ new Set([...context.visitedTypes, fieldDesc.typeName])
+      };
+      result.resolvedType = resolveProtoType(externalType, externalContext);
+    }
+  }
+  return result;
+}
+function resolveProtoType(protoType, context) {
+  if (!protoType.field) {
+    return { fields: {}, name: protoType.name };
+  }
+  const fields = {};
+  const oneofGroups = /* @__PURE__ */ new Map();
+  for (const fieldDesc of protoType.field) {
+    if (fieldDesc.oneofIndex !== void 0 && !fieldDesc.proto3Optional) {
+      const group = oneofGroups.get(fieldDesc.oneofIndex) || [];
+      group.push(fieldDesc.name);
+      oneofGroups.set(fieldDesc.oneofIndex, group);
+    }
+    fields[fieldDesc.name] = convertFieldDescriptor(fieldDesc, protoType, context);
+  }
+  return {
+    fields,
+    name: protoType.name,
+    // oneof 그룹 정보 (첫 번째 필드만 생성하도록)
+    oneofGroups: oneofGroups.size > 0 ? Object.fromEntries(oneofGroups) : void 0
+  };
+}
+function getResponseTypeInfo(methodDef, packageDefinition) {
+  const methodDefWithResponseType = methodDef;
+  const responseType = methodDefWithResponseType.responseType;
+  if (!responseType?.type?.field) {
+    return { name: "unknown" };
+  }
+  const context = {
+    packageDefinition,
+    visitedTypes: /* @__PURE__ */ new Set(),
+    depth: 0,
+    maxDepth: 5
+    // 최대 재귀 깊이
+  };
+  return resolveProtoType(responseType.type, context);
 }
 export default defineEventHandler(async (event) => {
   const config = useRuntimeConfig(event);
@@ -147,8 +283,9 @@ export default defineEventHandler(async (event) => {
   } catch {
     requestBody = {};
   }
-  const responseTypeInfo = getResponseTypeInfo(methodDef);
-  const seed = deriveSeedFromRequest(requestBody);
+  const responseTypeInfo = getResponseTypeInfo(methodDef, cache.packageDefinition);
+  const seedNum = deriveSeedFromRequest(requestBody);
+  const seed = String(seedNum);
   const paginationInfo = analyzeProtoPagination(responseTypeInfo);
   let mockResponse;
   if (paginationInfo) {
@@ -217,7 +354,7 @@ export default defineEventHandler(async (event) => {
       mockResponse = responseData;
     }
   } else {
-    mockResponse = generateMockMessage(responseTypeInfo, seed);
+    mockResponse = generateMockMessage(responseTypeInfo, seedNum);
   }
   return {
     success: true,

package/dist/runtime/server/handlers/schema.js

@@ -2,7 +2,8 @@ import { defineEventHandler, createError } from "h3";
 import { useRuntimeConfig } from "#imports";
 import { consola } from "consola";
 import { createRequire } from "node:module";
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join, extname } from "pathe";
 import yaml from "js-yaml";
 import { getClientPackage } from "../utils/client-parser.js";
 const logger = consola.withTag("mock-fried");
@@ -180,18 +181,46 @@ function parseOpenApiSpec(specPath) {
     return void 0;
   }
 }
+function findProtoFiles(dirPath) {
+  const files = [];
+  const stat = statSync(dirPath);
+  if (stat.isFile() && extname(dirPath) === ".proto") {
+    return [dirPath];
+  }
+  if (stat.isDirectory()) {
+    const entries = readdirSync(dirPath);
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry);
+      const entryStat = statSync(fullPath);
+      if (entryStat.isFile() && extname(entry) === ".proto") {
+        files.push(fullPath);
+      } else if (entryStat.isDirectory()) {
+        files.push(...findProtoFiles(fullPath));
+      }
+    }
+  }
+  return files;
+}
 async function parseProtoSpec(protoPath) {
   if (!existsSync(protoPath)) {
     return void 0;
   }
   try {
     const protoLoader = await import("@grpc/proto-loader");
-    const packageDefinition = await protoLoader.load(protoPath, {
+    const { dirname } = await import("pathe");
+    const stat = statSync(protoPath);
+    const protoFiles = stat.isDirectory() ? findProtoFiles(protoPath) : [protoPath];
+    const includeDir = stat.isDirectory() ? protoPath : dirname(protoPath);
+    if (protoFiles.length === 0) {
+      return void 0;
+    }
+    const packageDefinition = await protoLoader.load(protoFiles, {
       keepCase: false,
       longs: String,
       enums: String,
       defaults: true,
-      oneofs: true
+      oneofs: true,
+      includeDirs: [includeDir]
     });
     const services = [];
     let packageName;

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

@@ -12,19 +12,22 @@ function parseApiFile(filePath, fileName) {
   while ((match = methodBodyRegex.exec(content)) !== null) {
     const methodName = match[1];
     const body = match[2];
-    methodBodies.set(methodName, body);
+    if (methodName && body) {
+      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];
+    if (!jsdocContent || !operationId || !responseType) continue;
     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(/let\s+urlPath\s*=\s*`([^`]+)`/);
-    if (!pathMatch) continue;
+    if (!pathMatch?.[1]) continue;
     let path = pathMatch[1];
     path = path.replace(/\$\{[^}]+\}/g, (match2) => {
       const paramName = match2.match(/requestParameters(?:\.(\w+)|\["?(\w+)"?\])/)?.[1] || match2.match(/requestParameters(?:\.(\w+)|\["?(\w+)"?\])/)?.[2];
@@ -38,25 +41,31 @@ function parseApiFile(filePath, fileName) {
     const pathParams = [];
     const pathParamMatches = path.matchAll(/\{(\w+)\}/g);
     for (const pm of pathParamMatches) {
-      pathParams.push({
-        name: pm[1],
-        type: "string",
-        required: true
-      });
+      const paramName = pm[1];
+      if (paramName) {
+        pathParams.push({
+          name: paramName,
+          type: "string",
+          required: true
+        });
+      }
     }
     const queryParams = [];
     const queryParamRegex = /if\s*\(requestParameters\[?['"]?(\w+)['"]?\]?\s*!==?\s*(?:undefined|null)\)\s*\{\s*queryParameters\[['"](\w+)['"]\]/g;
     let qpm;
     while ((qpm = queryParamRegex.exec(body)) !== null) {
-      queryParams.push({
-        name: qpm[2],
-        type: "string",
-        required: false
-      });
+      const paramName = qpm[2];
+      if (paramName) {
+        queryParams.push({
+          name: paramName,
+          type: "string",
+          required: false
+        });
+      }
     }
     let requestBodyType;
     const bodyMatch = body.match(/body:\s*(\w+)ToJSON\(requestParameters\.(\w+)\)/);
-    if (bodyMatch) {
+    if (bodyMatch?.[1]) {
       requestBodyType = bodyMatch[1];
     }
     endpoints.push({
@@ -79,7 +88,7 @@ function analyzeType(rawType) {
   let type = rawType;
   if (isArray) {
     const arrayTypeMatch = rawType.match(/Array<(.+)>/) || rawType.match(/(.+)\[\]/);
-    if (arrayTypeMatch) {
+    if (arrayTypeMatch?.[1]) {
       type = arrayTypeMatch[1].trim();
     }
   }
@@ -96,11 +105,13 @@ function parseModelFile(filePath, fileName) {
   if (!hasInterface) {
     const enumRegex = new RegExp(`export\\s+const\\s+(${modelName})\\s*=\\s*\\{([^}]+)\\}\\s*as\\s*const`);
     const enumMatch = content.match(enumRegex);
-    if (enumMatch) {
+    if (enumMatch?.[2]) {
       const enumValues = [];
       const valueMatches = enumMatch[2].matchAll(/(\w+):\s*['"]([^'"]+)['"]/g);
       for (const vm of valueMatches) {
-        enumValues.push(vm[2]);
+        if (vm[2]) {
+          enumValues.push(vm[2]);
+        }
       }
       if (enumValues.length > 0) {
         return {
@@ -114,11 +125,12 @@ function parseModelFile(filePath, fileName) {
   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) {
+  if (toJsonMatch?.[1]) {
     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];
+      if (!jsonKey) continue;
       const propertyName = fm[2] || fm[3];
       if (!propertyName) continue;
       jsonKeyMap.set(propertyName, jsonKey);
@@ -134,29 +146,31 @@ function parseModelFile(filePath, fileName) {
     }
   }
   const fromJsonMatch = content.match(/export\s+function\s+\w+FromJSONTyped[^{]*\{[\s\S]*?return\s*\{([\s\S]*?)\};?\s*\}/);
-  if (fromJsonMatch) {
+  if (fromJsonMatch?.[1]) {
     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]);
+      if (dm[1]) 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]);
+      if (am[1]) 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")) {
+      if (rm[1] && rm[2] && !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]);
+      if (arm[1] && arm[2]) {
+        refTypeMap.set(arm[1], arm[2]);
+        arrayFields.add(arm[1]);
+      }
     }
     for (const field of fields) {
       if (dateFields.has(field.name)) {
@@ -173,14 +187,16 @@ function parseModelFile(filePath, fileName) {
     }
   }
   const interfaceMatch = content.match(/export\s+interface\s+(\w+)(?:\s+extends\s+[\w,\s]+)?\s*\{([\s\S]*?)\n\}/);
-  if (interfaceMatch) {
+  if (interfaceMatch?.[2]) {
     const interfaceBody = interfaceMatch[2];
     const simpleFieldRegex = /^\s+(\w+)(\?)?:\s*([^;]+);/gm;
     let sfm;
     while ((sfm = simpleFieldRegex.exec(interfaceBody)) !== null) {
       const name = sfm[1];
+      const rawTypeStr = sfm[3];
+      if (!name || !rawTypeStr) continue;
       const optional = sfm[2] === "?";
-      const rawType = sfm[3].trim();
+      const rawType = rawTypeStr.trim();
       const { type, isArray, refType } = analyzeType(rawType);
       const existingField = fields.find((f) => f.name === name);
       if (existingField) {

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

@@ -2,10 +2,24 @@
  * Proto 필드 타입에 따른 mock 값 생성
  */
 export declare function generateMockValueForProtoField(fieldName: string, fieldType: string, seed?: number): unknown;
+/**
+ * 재귀 생성 옵션
+ */
+export interface MockGenerationOptions {
+    /** 현재 재귀 깊이 */
+    depth?: number;
+    /** 최대 재귀 깊이 (기본: 3) */
+    maxDepth?: number;
+    /** 방문한 타입 이름 Set (간접 재귀 감지) */
+    visitedTypes?: Set<string>;
+    /** 현재 타입 이름 */
+    typeName?: string;
+}
 /**
  * Proto 메시지 타입에서 mock 객체 생성
+ * 재귀적 타입 지원 (깊이 제한으로 무한 루프 방지)
  */
-export declare function generateMockMessage(messageType: Record<string, unknown>, seed?: number): Record<string, unknown>;
+export declare function generateMockMessage(messageType: Record<string, unknown>, seed?: number, options?: MockGenerationOptions): Record<string, unknown>;
 /**
  * 요청 객체에서 seed 추출
  */

package/dist/runtime/server/utils/mock/proto-generator.js

@@ -30,7 +30,23 @@ export function generateMockValueForProtoField(fieldName, fieldType, seed = 1) {
       return null;
   }
 }
-export function generateMockMessage(messageType, seed = 1) {
+export function generateMockMessage(messageType, seed = 1, options = {}) {
+  const {
+    depth = 0,
+    maxDepth = 3,
+    visitedTypes = /* @__PURE__ */ new Set(),
+    typeName
+  } = options;
+  if (depth >= maxDepth) {
+    return {};
+  }
+  if (typeName && visitedTypes.has(typeName)) {
+    return {};
+  }
+  const newVisitedTypes = new Set(visitedTypes);
+  if (typeName) {
+    newVisitedTypes.add(typeName);
+  }
   const result = {};
   const fields = messageType.fields || {};
   let currentSeed = seed;
@@ -41,15 +57,42 @@ export function generateMockMessage(messageType, seed = 1) {
       const resolvedType = field.resolvedType;
       if (resolvedType.values) {
         const enumValues = Object.keys(resolvedType.values);
-        value = enumValues[0] || "UNKNOWN";
+        const random = seededRandom(currentSeed);
+        const index = Math.floor(random() * enumValues.length);
+        value = enumValues[index] || "UNKNOWN";
       } else if (resolvedType.fields) {
-        value = generateMockMessage(resolvedType, currentSeed);
+        const nestedTypeName = resolvedType.name || field.typeName || fieldName;
+        value = generateMockMessage(resolvedType, currentSeed, {
+          depth: depth + 1,
+          maxDepth,
+          visitedTypes: newVisitedTypes,
+          typeName: nestedTypeName
+        });
       }
     } else {
       value = generateMockValueForProtoField(fieldName, field.type || "string", currentSeed);
     }
     if (field.rule === "repeated") {
-      value = [value];
+      if (depth < maxDepth - 1 && value && typeof value === "object") {
+        const itemCount = Math.max(1, 3 - depth);
+        const items = [value];
+        for (let i = 1; i < itemCount; i++) {
+          if (field.resolvedType) {
+            const resolvedType = field.resolvedType;
+            if (resolvedType.fields) {
+              items.push(generateMockMessage(resolvedType, currentSeed + i * 100, {
+                depth: depth + 1,
+                maxDepth,
+                visitedTypes: newVisitedTypes,
+                typeName: resolvedType.name || field.typeName || fieldName
+              }));
+            }
+          }
+        }
+        value = items;
+      } else {
+        value = value !== null && value !== void 0 ? [value] : [];
+      }
     }
     if (field.keyType) {
       const keyValue = field.keyType === "string" ? `key_${currentSeed}` : currentSeed;

package/dist/runtime/server/utils/mock/providers/proto-item-provider.js

@@ -90,6 +90,9 @@ export function analyzeProtoPagination(messageType) {
   const foundCursorFields = cursorFieldPatterns.filter((p) => fieldNames.includes(p.toLowerCase()));
   const isPageBased = foundPageFields.length >= 2;
   const isCursorBased = foundCursorFields.length >= 1;
+  if (!isPageBased && !isCursorBased) {
+    return null;
+  }
   return {
     itemsFieldName,
     itemMessageType,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mock-fried",
-  "version": "1.0.7",
+  "version": "1.1.1",
   "description": "Nuxt3 Mock API Module - OpenAPI & Protobuf RPC Mock Server",
   "repository": {
     "type": "git",
@@ -52,12 +52,14 @@
     "format:check": "prettier --check .",
     "test": "vitest run",
     "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
     "test:unit": "vitest run --exclude 'test/e2e/**'",
     "test:e2e": "vitest run test/e2e/",
     "test:e2e:openapi": "vitest run test/e2e/playground-openapi.e2e.test.ts",
     "test:e2e:openapi-client": "vitest run test/e2e/playground-openapi-client.e2e.test.ts",
-    "test:e2e:proto": "vitest run test/e2e/playground-proto.e2e.test.ts",
-    "test:types": "vue-tsc --noEmit && cd playground-openapi && vue-tsc --noEmit"
+    "test:e2e:proto": "vitest run test/e2e/playground-proto.e2e.test.ts test/e2e/playground-proto-advanced.e2e.test.ts",
+    "test:e2e:proto-advanced": "vitest run test/e2e/playground-proto-advanced.e2e.test.ts",
+    "test:types": "vue-tsc --noEmit"
   },
   "dependencies": {
     "@grpc/grpc-js": "^1.12.0",
@@ -77,6 +79,7 @@
     "@nuxt/test-utils": "^3.21.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "latest",
+    "@vitest/coverage-v8": "^4.0.16",
     "changelogen": "^0.6.2",
     "eslint": "^9.39.2",
     "nuxt": "^4.2.2",