mock-fried 1.0.6 → 1.0.7

package/README.md

@@ -278,7 +278,7 @@ Mock-Fried는 **결정론적(deterministic)** Mock 데이터를 생성합니다:
 | Request Body | ✅ | POST/PUT/PATCH body 처리 |
 | All HTTP Methods | ✅ | GET, POST, PUT, DELETE, PATCH |
 
-### Protobuf RPC Mock (⚠️ Basic Support)
+### Protobuf RPC Mock (✅ Production Ready)
 
 | Feature | Status | Description |
 |---------|--------|-------------|
@@ -288,20 +288,20 @@ Mock-Fried는 **결정론적(deterministic)** Mock 데이터를 생성합니다:
 | Basic Types | ✅ | string, int32/64, float, double, bool |
 | Enum Types | ✅ | 첫 번째 enum 값 반환 |
 | Nested Messages | ✅ | 중첩 메시지 타입 |
-| Repeated Fields | ✅ | 배열 필드 (단일 요소) |
+| Repeated Fields | ✅ | 배열 필드 (자동 생성) |
 | Map Fields | ✅ | map 타입 지원 |
+| Page Pagination | ✅ | page/limit 기반 페이지네이션 |
+| Cursor Pagination | ✅ | cursor 기반 무한 스크롤 |
+| Deterministic Data | ✅ | 동일 요청 = 동일 응답 |
 | Server Streaming | ❌ | 미구현 |
 | Client Streaming | ❌ | 미구현 |
 | Bidirectional Streaming | ❌ | 미구현 |
-| Pagination | ❌ | 미구현 |
-| Dynamic List Size | ❌ | repeated 필드 고정 1개 |
 
 ### 구현 예정 (Roadmap)
 
 Proto RPC 기능 확장:
+
 - [ ] Server streaming 지원
-- [ ] Pagination 패턴 지원
-- [ ] repeated 필드 다수 아이템 생성
 - [ ] Well-known types (Timestamp, Duration 등)
 
 ## Compatibility

package/dist/module.json

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

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

@@ -20,6 +20,7 @@ let apiInstance = null;
 let cachedSpecPath = null;
 let specCursorManager = null;
 let specPageManager = null;
+let cachedOpenAPISpec = null;
 function loadOpenAPISpec(specPath) {
   const content = readFileSync(specPath, "utf-8");
   if (specPath.endsWith(".yaml") || specPath.endsWith(".yml")) {
@@ -33,10 +34,12 @@ async function getOpenAPIBackend(specPath) {
   }
   const { OpenAPIBackend } = await import("openapi-backend");
   const definition = loadOpenAPISpec(specPath);
+  cachedOpenAPISpec = definition;
   apiInstance = new OpenAPIBackend({
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     definition,
-    quick: true,
+    quick: false,
+    // $ref 역참조를 위해 false로 설정
     validate: false
     // Mock 서버에서는 request validation 비활성화
   });
@@ -52,6 +55,13 @@ async function getOpenAPIBackend(specPath) {
     notImplemented: async (c) => {
       const operationId = c.operation?.operationId || "unknown";
       const responses = c.operation?.responses;
+      if (responses?.["204"]) {
+        return {
+          statusCode: 204,
+          body: null,
+          meta: { operationId }
+        };
+      }
       const successResponse = responses?.["200"] || responses?.["201"] || Object.values(responses || {})[0];
       const content = successResponse?.content;
       const jsonContent = content?.["application/json"];
@@ -138,7 +148,16 @@ async function getOpenAPIBackend(specPath) {
           }
         } else {
           const numericSeed = hashString(seed);
-          mockData = generateMockFromSchema(schema, numericSeed);
+          const apiSchemas = c.api?.document?.components?.schemas;
+          const schemaContext = {
+            schemas: apiSchemas || cachedOpenAPISpec?.components?.schemas,
+            maxDepth: 10
+          };
+          mockData = generateMockFromSchema(
+            schema,
+            numericSeed,
+            schemaContext
+          );
         }
       }
       return {
@@ -170,6 +189,7 @@ let pagePaginationManager = null;
 export function clearOpenApiCache() {
   apiInstance = null;
   cachedSpecPath = null;
+  cachedOpenAPISpec = null;
   cachedClientPackage = null;
   cachedClientPath = null;
   mockGenerator = null;
@@ -236,7 +256,18 @@ function handleClientPackageRequest(pkg, generator, cursorManager, pageManager,
     };
   }
   const { endpoint, pathParams } = match;
-  const primitiveTypes = ["object", "string", "number", "boolean", "void", "any", "unknown"];
+  if (endpoint.responseType.toLowerCase() === "void") {
+    return {
+      statusCode: 204,
+      body: null,
+      meta: {
+        operationId: endpoint.operationId,
+        apiClass: endpoint.apiClassName,
+        responseType: endpoint.responseType
+      }
+    };
+  }
+  const primitiveTypes = ["object", "string", "number", "boolean", "any", "unknown"];
   if (primitiveTypes.includes(endpoint.responseType.toLowerCase())) {
     const pathLower = path.toLowerCase();
     let primitiveResponse = {};

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

@@ -24,6 +24,7 @@ export declare function inferNumberByFieldName(fieldName: string, rng: SeededRan
 export declare function inferBooleanByFieldName(fieldName: string, rng: SeededRandom): boolean;
 /**
  * Date 타입 필드의 값 생성
+ * 결정적 타임스탬프 생성 (2024-01-01 기준)
  */
 export declare function inferDateByFieldName(fieldName: string, rng: SeededRandom): string;
 /**

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

@@ -23,9 +23,9 @@ export function inferValueByFieldName(fieldName, rng, index = 0, idConfig = DEFA
     return `https://picsum.photos/seed/${rng.nextInt(1, 1e3)}/200/200`;
   }
   if (name.includes("date") || name.endsWith("at") || name.includes("time") || name.includes("created") || name.includes("updated")) {
-    const now = Date.now();
-    const offset = rng.nextInt(-365, 30) * 24 * 60 * 60 * 1e3;
-    return new Date(now + offset).toISOString();
+    const baseTimestamp = 17040672e5;
+    const offset = rng.nextInt(-365, 365) * 24 * 60 * 60 * 1e3;
+    return new Date(baseTimestamp + offset).toISOString();
   }
   if (name.includes("description") || name.includes("content") || name.includes("body") || name.includes("text")) {
     return `Mock ${fieldName} \uB370\uC774\uD130 #${rng.nextInt(1, 100)}`;
@@ -219,29 +219,29 @@ export function inferBooleanByFieldName(fieldName, rng) {
 }
 export function inferDateByFieldName(fieldName, rng) {
   const name = fieldName.toLowerCase();
-  const now = Date.now();
+  const baseTimestamp = 17040672e5;
   if (name.includes("created") || name.includes("registered") || name.includes("joined")) {
     const offset2 = rng.nextInt(-365, -1) * 24 * 60 * 60 * 1e3;
-    return new Date(now + offset2).toISOString();
+    return new Date(baseTimestamp + offset2).toISOString();
   }
   if (name.includes("updated") || name.includes("modified")) {
     const offset2 = rng.nextInt(-30, 0) * 24 * 60 * 60 * 1e3;
-    return new Date(now + offset2).toISOString();
+    return new Date(baseTimestamp + offset2).toISOString();
   }
   if (name.includes("expir") || name.includes("deadline") || name.includes("due")) {
     const offset2 = rng.nextInt(1, 365) * 24 * 60 * 60 * 1e3;
-    return new Date(now + offset2).toISOString();
+    return new Date(baseTimestamp + offset2).toISOString();
   }
   if (name.includes("start") || name.includes("begin")) {
     const offset2 = rng.nextInt(-30, 30) * 24 * 60 * 60 * 1e3;
-    return new Date(now + offset2).toISOString();
+    return new Date(baseTimestamp + offset2).toISOString();
   }
   if (name.includes("end") || name.includes("finish")) {
     const offset2 = rng.nextInt(1, 90) * 24 * 60 * 60 * 1e3;
-    return new Date(now + offset2).toISOString();
+    return new Date(baseTimestamp + offset2).toISOString();
   }
-  const offset = rng.nextInt(-365, 30) * 24 * 60 * 60 * 1e3;
-  return new Date(now + offset).toISOString();
+  const offset = rng.nextInt(-365, 365) * 24 * 60 * 60 * 1e3;
+  return new Date(baseTimestamp + offset).toISOString();
 }
 export function inferStringByFieldName(fieldName, rng, index = 0, idConfig = DEFAULT_ID_CONFIG) {
   const inferred = inferValueByFieldName(fieldName, rng, index, idConfig);
@@ -270,9 +270,9 @@ export function inferTypeFromFieldName(fieldName, rng, index, idConfig = DEFAULT
     return rng.next() > 0.5;
   }
   if (name.includes("date") || name.endsWith("at") || name.includes("time") || name.includes("created") || name.includes("updated") || name.includes("modified") || name.includes("deadline")) {
-    const now = Date.now();
-    const offset = rng.nextInt(-365, 30) * 24 * 60 * 60 * 1e3;
-    return new Date(now + offset).toISOString();
+    const baseTimestamp = 17040672e5;
+    const offset = rng.nextInt(-365, 365) * 24 * 60 * 60 * 1e3;
+    return new Date(baseTimestamp + offset).toISOString();
   }
   if (name.includes("days") || name.includes("months") || name.includes("weeks") || name.includes("years")) {
     return rng.nextInt(1, 30);

package/dist/runtime/server/utils/mock/index.d.ts

@@ -4,6 +4,6 @@
  */
 export { hashString, seededRandom, SeededRandom, generateId, generateSnapshotId, DEFAULT_ID_CONFIG, isIdField, generateIdValue, generateByFormat, } from './shared.js';
 export { generateMockValueForProtoField, generateMockMessage, deriveSeedFromRequest, } from './proto-generator.js';
-export { generateMockFromSchema, } from './openapi-generator.js';
+export { generateMockFromSchema, type SchemaContext, } from './openapi-generator.js';
 export { inferValueByFieldName, generateValueByType, inferTypeFromFieldName, SchemaMockGenerator, extractDataModelName, type ResponseTypeInfo, } from './client-generator.js';
 export { type CursorPayload, type PaginationSnapshot, type PagePaginationOptions, type PagePaginationResult, type CursorPaginationOptions, type CursorPaginationResult, type PaginationConfig, type CursorConfig, DEFAULT_PAGINATION_CONFIG, DEFAULT_CURSOR_CONFIG, SnapshotStore, getSnapshotStore, resetSnapshotStore, CursorPaginationManager, encodeCursor, decodeCursor, isCursorExpired, PagePaginationManager, } from './pagination/index.js';

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

@@ -1,4 +1,18 @@
+/**
+ * $ref 참조를 해결하는 컨텍스트
+ */
+export interface SchemaContext {
+    schemas?: Record<string, Record<string, unknown>>;
+    maxDepth?: number;
+    /** 현재 처리 중인 스키마 경로 (순환 참조 감지용) */
+    _visitedRefs?: Set<string>;
+}
 /**
  * OpenAPI 스키마에서 mock 값 생성
+ * @param schema - OpenAPI 스키마
+ * @param seed - 랜덤 시드
+ * @param context - $ref 해결을 위한 컨텍스트
+ * @param depth - 현재 재귀 깊이 (재귀 스키마 무한 루프 방지)
+ * @param debugPath - 디버그용 경로 (개발 시에만 사용)
  */
-export declare function generateMockFromSchema(schema: Record<string, unknown>, seed?: number): unknown;
+export declare function generateMockFromSchema(schema: Record<string, unknown>, seed?: number, context?: SchemaContext, depth?: number, debugPath?: string): unknown;

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

@@ -1,6 +1,40 @@
 import { seededRandom } from "./shared.js";
-export function generateMockFromSchema(schema, seed = 1) {
+function extractRefName(ref) {
+  const parts = ref.split("/");
+  return parts[parts.length - 1] || "";
+}
+function resolveRef(schema, context) {
+  const ref = schema.$ref;
+  if (!ref) return schema;
+  const schemaName = extractRefName(ref);
+  const resolved = context.schemas?.[schemaName];
+  if (!resolved) {
+    return schema;
+  }
+  return resolved;
+}
+export function generateMockFromSchema(schema, seed = 1, context = {}, depth = 0, debugPath = "root") {
+  const maxDepth = context.maxDepth ?? 5;
   const random = seededRandom(seed);
+  if (depth > maxDepth) {
+    return null;
+  }
+  if (schema.$ref) {
+    const refPath = schema.$ref;
+    const visitedRefs = context._visitedRefs ?? /* @__PURE__ */ new Set();
+    const refKey = `${refPath}@${depth}`;
+    if (visitedRefs.has(refKey)) {
+      return null;
+    }
+    const newVisitedRefs = new Set(visitedRefs);
+    newVisitedRefs.add(refKey);
+    const newContext = { ...context, _visitedRefs: newVisitedRefs };
+    const resolved = resolveRef(schema, context);
+    if (resolved !== schema) {
+      return generateMockFromSchema(resolved, seed, newContext, depth + 1, `${debugPath}->$ref`);
+    }
+    return null;
+  }
   const schemaType = schema.type;
   if (schema.example !== void 0) {
     return schema.example;
@@ -8,6 +42,38 @@ export function generateMockFromSchema(schema, seed = 1) {
   if (Array.isArray(schema.enum) && schema.enum.length > 0) {
     return schema.enum[0];
   }
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+    const index = Math.floor(random() * schema.oneOf.length);
+    return generateMockFromSchema(
+      schema.oneOf[index],
+      seed,
+      context,
+      depth + 1,
+      `${debugPath}->oneOf[${index}]`
+    );
+  }
+  if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+    const index = Math.floor(random() * schema.anyOf.length);
+    return generateMockFromSchema(
+      schema.anyOf[index],
+      seed,
+      context,
+      depth + 1,
+      `${debugPath}->anyOf[${index}]`
+    );
+  }
+  if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+    const merged = {};
+    let propSeed = seed;
+    let idx = 0;
+    for (const subSchema of schema.allOf) {
+      const generated = generateMockFromSchema(subSchema, propSeed++, context, depth + 1, `${debugPath}->allOf[${idx++}]`);
+      if (typeof generated === "object" && generated !== null) {
+        Object.assign(merged, generated);
+      }
+    }
+    return merged;
+  }
   switch (schemaType) {
     case "string": {
       const format = schema.format;
@@ -59,26 +125,27 @@ export function generateMockFromSchema(schema, seed = 1) {
       const items = schema.items;
       if (items) {
         const minItems = schema.minItems ?? 1;
-        const maxItems = schema.maxItems ?? 3;
+        const maxItems = schema.maxItems ?? (depth > 3 ? 1 : 3);
         const count = Math.floor(random() * (maxItems - minItems + 1)) + minItems;
         return Array.from(
           { length: count },
-          (_, i) => generateMockFromSchema(items, seed + i + 1)
+          (_, i) => generateMockFromSchema(items, seed + i + 1, context, depth + 1, `${debugPath}[${i}]`)
         );
       }
       return [];
     }
-    case "object": {
+    case "object":
+    default: {
       const properties = schema.properties;
       if (properties) {
         const result = {};
         const required = schema.required ?? [];
         let propSeed = seed;
         for (const [propName, propSchema] of Object.entries(properties)) {
-          if (!required.includes(propName) && random() < 0.5) {
+          if (!required.includes(propName) && random() < 0.2) {
             continue;
           }
-          result[propName] = generateMockFromSchema(propSchema, propSeed++);
+          result[propName] = generateMockFromSchema(propSchema, propSeed++, context, depth + 1, `${debugPath}.${propName}`);
         }
         return result;
       }
@@ -86,31 +153,18 @@ export function generateMockFromSchema(schema, seed = 1) {
         const additionalProps = schema.additionalProperties;
         if (typeof additionalProps === "object") {
           return {
-            [`key_${seed}`]: generateMockFromSchema(additionalProps, seed + 1)
+            key1: generateMockFromSchema(additionalProps, seed, context, depth + 1, `${debugPath}.key1`),
+            key2: generateMockFromSchema(additionalProps, seed + 1, context, depth + 1, `${debugPath}.key2`),
+            key3: generateMockFromSchema(additionalProps, seed + 2, context, depth + 1, `${debugPath}.key3`)
           };
         }
+        return {
+          key1: "value1",
+          key2: "value2"
+        };
       }
-      return {};
-    }
-    // oneOf, anyOf, allOf 처리
-    default: {
-      if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-        const index = Math.floor(random() * schema.oneOf.length);
-        return generateMockFromSchema(schema.oneOf[index], seed);
-      }
-      if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
-        const index = Math.floor(random() * schema.anyOf.length);
-        return generateMockFromSchema(schema.anyOf[index], seed);
-      }
-      if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-        const merged = {};
-        for (const subSchema of schema.allOf) {
-          const generated = generateMockFromSchema(subSchema, seed);
-          if (typeof generated === "object" && generated !== null) {
-            Object.assign(merged, generated);
-          }
-        }
-        return merged;
+      if (schemaType === "object") {
+        return {};
       }
       return null;
     }

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

@@ -42,6 +42,9 @@ export class OpenAPIItemProvider {
    */
   generateItemWithId(id, index, seed) {
     const item = this.generateItem(index, seed);
+    if (typeof item !== "object" || item === null) {
+      return { [this.idFieldName]: id, value: item };
+    }
     item[this.idFieldName] = id;
     return item;
   }
@@ -100,6 +103,9 @@ export function analyzePaginationSchema(schema) {
   const foundCursorFields = cursorFields.filter((f) => f in properties);
   const isPageBased = foundPageFields.length >= 2;
   const isCursorBased = foundCursorFields.length >= 1;
+  if (!isPageBased && !isCursorBased) {
+    return null;
+  }
   return {
     itemsFieldName,
     itemSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mock-fried",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Nuxt3 Mock API Module - OpenAPI & Protobuf RPC Mock Server",
   "repository": {
     "type": "git",
@@ -52,6 +52,11 @@
     "format:check": "prettier --check .",
     "test": "vitest run",
     "test:watch": "vitest watch",
+    "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"
   },
   "dependencies": {