mock-fried 1.1.0 → 1.1.1

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "1.1.0",
+  "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

@@ -86,6 +86,7 @@ export function clearProtoCache() {
   protoPageManager = null;
 }
 const PROTO_TYPE_MAP = {
+  // 숫자 키 (legacy/fallback)
   1: "double",
   2: "float",
   3: "int64",
@@ -97,25 +98,57 @@ const PROTO_TYPE_MAP = {
   9: "string",
   10: "group",
   11: "message",
-  // 중첩 메시지
   12: "bytes",
   13: "uint32",
   14: "enum",
   15: "sfixed32",
   16: "sfixed64",
   17: "sint32",
-  18: "sint64"
+  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 typeInfo = packageDefinition[cleanName];
-  return typeInfo?.type || null;
+  const directMatch = packageDefinition[cleanName];
+  if (directMatch?.type) {
+    return directMatch.type;
+  }
+  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: fieldDesc.label === 3 ? "repeated" : void 0
+    rule: isRepeated ? "repeated" : void 0
   };
   if (fieldDesc.typeName) {
     const shortName = fieldDesc.typeName.split(".").pop() || fieldDesc.typeName;
@@ -123,10 +156,6 @@ function convertFieldDescriptor(fieldDesc, protoType, context) {
     if (context.depth >= context.maxDepth) {
       return result;
     }
-    if (context.visitedTypes.has(fieldDesc.typeName)) {
-      result.resolvedType = { fields: {}, name: shortName };
-      return result;
-    }
     const enumType = protoType.enumType?.find(
       (e) => e.name === shortName
     );
@@ -185,9 +214,10 @@ function resolveProtoType(protoType, context) {
   };
 }
 function getResponseTypeInfo(methodDef, packageDefinition) {
-  const responseType = methodDef.responseType;
+  const methodDefWithResponseType = methodDef;
+  const responseType = methodDefWithResponseType.responseType;
   if (!responseType?.type?.field) {
-    return {};
+    return { name: "unknown" };
   }
   const context = {
     packageDefinition,
@@ -254,7 +284,8 @@ export default defineEventHandler(async (event) => {
     requestBody = {};
   }
   const responseTypeInfo = getResponseTypeInfo(methodDef, cache.packageDefinition);
-  const seed = deriveSeedFromRequest(requestBody);
+  const seedNum = deriveSeedFromRequest(requestBody);
+  const seed = String(seedNum);
   const paginationInfo = analyzeProtoPagination(responseTypeInfo);
   let mockResponse;
   if (paginationInfo) {
@@ -323,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/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/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.1.0",
+  "version": "1.1.1",
   "description": "Nuxt3 Mock API Module - OpenAPI & Protobuf RPC Mock Server",
   "repository": {
     "type": "git",
@@ -59,7 +59,7 @@
     "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/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 && cd playground-openapi && vue-tsc --noEmit"
+    "test:types": "vue-tsc --noEmit"
   },
   "dependencies": {
     "@grpc/grpc-js": "^1.12.0",