mock-fried 1.0.5 → 1.0.7

package/README.md

@@ -2,6 +2,7 @@
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![CI][ci-src]][ci-href]
 [![License][license-src]][license-href]
 [![Nuxt][nuxt-src]][nuxt-href]
 
@@ -11,6 +12,8 @@ Nuxt 3 Mock API Module - OpenAPI & Protobuf RPC Mock Server
 
 - **OpenAPI Mock Server** - OpenAPI 스펙 기반 자동 Mock 응답 생성
 - **Protobuf RPC Mock** - Proto 파일 기반 gRPC-style RPC Mock
+- **Deterministic Data** - 동일한 요청에 대해 일관된 Mock 데이터 반환
+- **Pagination Support** - 페이지 기반 / 커서 기반 페이지네이션 지원
 - **API Explorer** - Swagger UI 스타일의 인터랙티브 API 테스트 UI
 - **Type-Safe Client** - `$api` 클라이언트로 타입 안전한 API 호출
 - **Zero Config** - 스펙 파일만 있으면 즉시 사용 가능
@@ -38,7 +41,7 @@ export default defineNuxtConfig({
     enable: true,
     prefix: '/mock',
     openapi: './mocks/openapi.yaml',  // OpenAPI 스펙 경로
-    proto: './mocks/example.proto',    // Proto 파일 경로
+    proto: './mocks/example.proto',    // Proto 파일 경로 (optional)
   },
 })
 ```
@@ -51,6 +54,8 @@ export default defineNuxtConfig({
 | `prefix` | `string` | `'/mock'` | API 라우트 prefix |
 | `openapi` | `string \| object` | - | OpenAPI 스펙 파일 경로 또는 클라이언트 패키지 설정 |
 | `proto` | `string` | - | Proto 파일 경로 |
+| `pagination` | `object` | - | 페이지 기반 페이지네이션 설정 |
+| `cursor` | `object` | - | 커서 기반 페이지네이션 설정 |
 
 ### OpenAPI 설정 옵션
 
@@ -63,6 +68,9 @@ mock: {
 
   // 절대 경로
   openapi: '/path/to/openapi.yaml',
+
+  // npm 패키지 내 스펙 파일
+  openapi: '@your-org/api-spec/openapi.yaml',
 }
 ```
 
@@ -85,26 +93,82 @@ mock: {
 - 실제 API 응답 구조와 일치하는 Mock 응답
 - snake_case/camelCase JSON 키 변환 자동 처리
 
+### Pagination 설정
+
+**페이지 기반 페이지네이션:**
+
+```typescript
+mock: {
+  openapi: { package: '@your-org/api-client' },
+  pagination: {
+    defaultLimit: 20,        // 기본 페이지 크기
+    maxLimit: 100,           // 최대 페이지 크기
+    totalItems: 100,         // 전체 아이템 수
+  },
+}
+```
+
+**커서 기반 페이지네이션:**
+
+```typescript
+mock: {
+  openapi: { package: '@your-org/api-client' },
+  cursor: {
+    defaultLimit: 20,
+    maxLimit: 100,
+    totalItems: 100,
+  },
+}
+```
+
 ## Usage
 
-### REST API (OpenAPI)
+### 직접 HTTP 호출 (권장)
+
+Mock 서버는 Nitro 핸들러로 동작하므로, Nuxt의 `useFetch`나 `$fetch`로 직접 호출할 수 있습니다.
+기존 API 클라이언트가 있다면 baseURL만 `/mock`으로 변경하여 사용하세요.
 
 ```typescript
-const { $api } = useNuxtApp()
+// useFetch 사용 (SSR 지원)
+const { data: users } = await useFetch('/mock/users')
+const { data: user } = await useFetch('/mock/users/123')
 
-// GET 요청
-const users = await $api.rest('/users')
+// $fetch 사용
+const products = await $fetch('/mock/products', {
+  query: { page: 1, limit: 10 }
+})
 
-// Path 파라미터
-const user = await $api.rest('/users/1')
+// 커서 기반 페이지네이션
+const items = await $fetch('/mock/items', {
+  query: { cursor: 'abc123', limit: 20 }
+})
+
+// POST 요청
+const newUser = await $fetch('/mock/users', {
+  method: 'POST',
+  body: { name: 'John', email: 'john@example.com' }
+})
+```
+
+### useApi Composable
+
+auto-import 되는 `useApi` composable로 타입 안전한 호출이 가능합니다.
+
+```typescript
+// useApi는 auto-import됨
+const api = useApi()
+
+// REST 호출
+const users = await api.rest('/users')
+const user = await api.rest('/users/123')
 
 // Query 파라미터
-const products = await $api.rest('/products', {
-  params: { category: 'electronics', limit: 10 }
+const products = await api.rest('/products', {
+  params: { page: 1, limit: 10 }
 })
 
 // POST 요청
-const newUser = await $api.rest('/users', {
+const newUser = await api.rest('/users', {
   method: 'POST',
   body: { name: 'John', email: 'john@example.com' }
 })
@@ -113,26 +177,57 @@ const newUser = await $api.rest('/users', {
 ### RPC (Protobuf)
 
 ```typescript
-const { $api } = useNuxtApp()
+const api = useApi()
 
 // 명시적 RPC 호출
-const user = await $api.rpc('UserService', 'GetUser', { id: 1 })
+const user = await api.rpc('UserService', 'GetUser', { id: 1 })
 
 // 동적 서비스 접근
-const user = await $api.UserService.GetUser({ id: 1 })
-const products = await $api.ProductService.ListProducts({ page: 1, limit: 10 })
+const user = await api.UserService.GetUser({ id: 1 })
+const products = await api.ProductService.ListProducts({ page: 1, limit: 10 })
+
+// 또는 직접 $fetch 사용
+const result = await $fetch('/mock/rpc/UserService/GetUser', {
+  method: 'POST',
+  body: { id: 1 }
+})
 ```
 
 ### API Schema 조회
 
 ```typescript
-const { $api } = useNuxtApp()
+const api = useApi()
 
 // 전체 스키마 조회
-const schema = await $api.getSchema()
+const schema = await api.getSchema()
 // { openapi: {...}, rpc: {...} }
+
+// 또는 직접 호출
+const schema = await $fetch('/mock/__schema')
 ```
 
+### 캐시 초기화
+
+개발 중 설정 변경 시 캐시를 초기화하려면:
+
+```typescript
+// POST 요청으로 캐시 초기화
+await $fetch('/mock/__reset', { method: 'POST' })
+```
+
+## Deterministic Mock Data
+
+Mock-Fried는 **결정론적(deterministic)** Mock 데이터를 생성합니다:
+
+- 동일한 엔드포인트 + path 파라미터 조합은 항상 동일한 데이터 반환
+- 예: `/users/1`과 `/users/2`는 각각 다른 일관된 데이터 반환
+- 서버 재시작 후에도 동일한 데이터 유지
+
+이를 통해:
+- 프론트엔드 개발 시 예측 가능한 테스트
+- E2E 테스트에서 안정적인 데이터 검증
+- UI 스냅샷 테스트 지원
+
 ## API Explorer
 
 모듈에 포함된 API Explorer 컴포넌트로 Swagger UI 스타일의 인터페이스 제공:
@@ -164,6 +259,64 @@ const schema = await $api.getSchema()
 | `/mock/rpc/:service/:method` | POST | RPC Mock 핸들러 |
 | `/mock/**` | * | OpenAPI Mock 핸들러 |
 
+## Implementation Coverage
+
+### OpenAPI Mock (✅ Production Ready)
+
+| Feature | Status | Description |
+|---------|--------|-------------|
+| Path Parameter | ✅ | `/users/{id}` → `/users/123` 매칭 |
+| Query Parameter | ✅ | `?page=1&limit=10` 파싱 |
+| Path Specificity | ✅ | 더 구체적인 경로 우선 매칭 |
+| Page Pagination | ✅ | page/limit 기반 페이지네이션 |
+| Cursor Pagination | ✅ | cursor 기반 무한 스크롤 |
+| Deterministic Data | ✅ | 동일 요청 = 동일 응답 |
+| Client Package Mode | ✅ | 생성된 TS 클라이언트 파싱 |
+| Spec File Mode | ✅ | YAML/JSON OpenAPI 스펙 |
+| Generic Types | ✅ | `Array<User>`, `PageResponse<T>` |
+| JSON Key Mapping | ✅ | snake_case ↔ camelCase |
+| Request Body | ✅ | POST/PUT/PATCH body 처리 |
+| All HTTP Methods | ✅ | GET, POST, PUT, DELETE, PATCH |
+
+### Protobuf RPC Mock (✅ Production Ready)
+
+| Feature | Status | Description |
+|---------|--------|-------------|
+| Unary RPC | ✅ | 단일 요청-응답 |
+| Service Routing | ✅ | `/rpc/:service/:method` |
+| Proto File Parsing | ✅ | .proto 파일 로드 |
+| Basic Types | ✅ | string, int32/64, float, double, bool |
+| Enum Types | ✅ | 첫 번째 enum 값 반환 |
+| Nested Messages | ✅ | 중첩 메시지 타입 |
+| Repeated Fields | ✅ | 배열 필드 (자동 생성) |
+| Map Fields | ✅ | map 타입 지원 |
+| Page Pagination | ✅ | page/limit 기반 페이지네이션 |
+| Cursor Pagination | ✅ | cursor 기반 무한 스크롤 |
+| Deterministic Data | ✅ | 동일 요청 = 동일 응답 |
+| Server Streaming | ❌ | 미구현 |
+| Client Streaming | ❌ | 미구현 |
+| Bidirectional Streaming | ❌ | 미구현 |
+
+### 구현 예정 (Roadmap)
+
+Proto RPC 기능 확장:
+
+- [ ] Server streaming 지원
+- [ ] Well-known types (Timestamp, Duration 등)
+
+## Compatibility
+
+| Environment | Support | Notes |
+|-------------|---------|-------|
+| Node.js Server | ✅ | 기본 대상 |
+| Nuxt 3/4 | ✅ | 테스트됨 |
+| Nitro SSR | ✅ | 번들 환경 지원 |
+| Edge Runtime | ❌ | fs 모듈 필요 |
+
+**요구사항:**
+- Node.js 18+
+- Nuxt 3.0+
+
 ## Development
 
 ```bash
@@ -173,9 +326,15 @@ yarn install
 # Generate type stubs
 yarn dev:prepare
 
-# Develop with OpenAPI playground
+# Prepare all playgrounds
+yarn dev:prepare:playground
+
+# Develop with OpenAPI Spec File Mode
 yarn dev:openapi
 
+# Develop with OpenAPI Client Package Mode
+yarn dev:openapi-client
+
 # Develop with Proto playground
 yarn dev:proto
 
@@ -208,8 +367,14 @@ mock-fried/
 │       └── server/
 │           ├── handlers/      # Nitro 서버 핸들러
 │           └── utils/         # Mock 데이터 생성 유틸
-├── playground-openapi/        # OpenAPI 테스트 환경
-└── playground-proto/          # Proto 테스트 환경
+├── packages/                  # 샘플 패키지 (CI + Playground 공용)
+│   ├── sample-openapi/        # OpenAPI 스펙 파일 (Spec File Mode)
+│   ├── openapi-client/        # openapi-generator 출력 (Client Package Mode)
+│   └── sample-proto/          # Proto 파일 샘플
+├── playground-openapi/        # Spec File Mode 테스트
+├── playground-openapi-client/ # Client Package Mode 테스트
+├── playground-proto/          # Proto RPC 테스트
+└── test/                      # E2E 테스트
 ```
 
 ## License
@@ -223,6 +388,9 @@ mock-fried/
 [npm-downloads-src]: https://img.shields.io/npm/dm/mock-fried.svg?style=flat&colorA=020420&colorB=00DC82
 [npm-downloads-href]: https://npm.chart.dev/mock-fried
 
+[ci-src]: https://img.shields.io/github/actions/workflow/status/TaeGyumKim/mock-fried/ci.yml?branch=main&style=flat&colorA=020420&colorB=00DC82
+[ci-href]: https://github.com/TaeGyumKim/mock-fried/actions/workflows/ci.yml
+
 [license-src]: https://img.shields.io/npm/l/mock-fried.svg?style=flat&colorA=020420&colorB=00DC82
 [license-href]: https://npmjs.com/package/mock-fried
 

package/dist/module.json

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

package/dist/module.mjs

@@ -1,6 +1,7 @@
 import { defineNuxtModule, createResolver, useLogger, addServerHandler, addPlugin, addImports, addComponentsDir } from '@nuxt/kit';
 import { normalize, resolve } from 'pathe';
 import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'node:fs';
 
 function parsePackagePath(specPath) {
   if (specPath.startsWith("@")) {
@@ -100,7 +101,25 @@ const module$1 = defineNuxtModule({
           const pkgJsonPath = require.resolve(`${options.openapi.package}/package.json`);
           clientPackagePath = normalize(resolve(pkgJsonPath, ".."));
         } catch {
-          logger.warn(`Failed to resolve client package: ${options.openapi.package}`);
+          try {
+            const pkgJsonPath = resolve(rootDir, "package.json");
+            if (existsSync(pkgJsonPath)) {
+              const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+              const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+              const depValue = deps[options.openapi.package];
+              if (depValue) {
+                if (depValue.startsWith("link:") || depValue.startsWith("file:")) {
+                  const relativePath = depValue.replace(/^(link:|file:)/, "");
+                  clientPackagePath = normalize(resolve(rootDir, relativePath));
+                  logger.info(`Resolved linked package: ${clientPackagePath}`);
+                }
+              }
+            }
+          } catch {
+          }
+          if (!clientPackagePath) {
+            logger.warn(`Failed to resolve client package: ${options.openapi.package}`);
+          }
         }
       }
     }

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

@@ -11,9 +11,16 @@ import {
   CursorPaginationManager,
   PagePaginationManager
 } from "../utils/mock/index.js";
+import {
+  OpenAPIItemProvider,
+  analyzePaginationSchema
+} from "../utils/mock/providers/index.js";
 import { getClientPackage } from "../utils/client-parser.js";
 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")) {
@@ -27,9 +34,14 @@ 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 비활성화
   });
   apiInstance.register({
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -43,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"];
@@ -50,8 +69,96 @@ async function getOpenAPIBackend(specPath) {
       if (jsonContent?.example) {
         mockData = jsonContent.example;
       } else if (jsonContent?.schema) {
-        const seed = hashString(operationId + JSON.stringify(c.request?.params || {}));
-        mockData = generateMockFromSchema(jsonContent.schema, seed);
+        const schema = jsonContent.schema;
+        const seed = `${operationId}-${JSON.stringify(c.request?.params || {})}`;
+        const paginationInfo = analyzePaginationSchema(schema);
+        if (paginationInfo) {
+          const query = c.request?.query || {};
+          const page = Number(query.page) || 1;
+          const limit = Number(query.limit) || Number(query.size) || 20;
+          const cursor = query.cursor;
+          const total = 100;
+          const itemProvider = new OpenAPIItemProvider(paginationInfo.itemSchema, {
+            modelName: operationId
+          });
+          if (!specCursorManager) {
+            specCursorManager = new CursorPaginationManager(itemProvider);
+          }
+          if (!specPageManager) {
+            specPageManager = new PagePaginationManager(itemProvider);
+          }
+          if (cursor || paginationInfo.isCursorBased) {
+            const result = specCursorManager.getCursorPageWithProvider(itemProvider, {
+              cursor,
+              limit,
+              total,
+              seed
+            });
+            const responseData = {
+              [paginationInfo.itemsFieldName]: result.items
+            };
+            if (paginationInfo.metaFields.includes("nextCursor")) {
+              responseData.nextCursor = result.nextCursor;
+            }
+            if (paginationInfo.metaFields.includes("prevCursor")) {
+              responseData.prevCursor = result.prevCursor;
+            }
+            if (paginationInfo.metaFields.includes("hasMore")) {
+              responseData.hasMore = result.hasMore;
+            }
+            if (paginationInfo.metaFields.includes("total")) {
+              responseData.total = total;
+            }
+            if (paginationInfo.metaFields.includes("cursor")) {
+              responseData.cursor = result.nextCursor;
+            }
+            mockData = responseData;
+          } else {
+            const result = specPageManager.getPagedResponseWithProvider(itemProvider, {
+              page,
+              limit,
+              total,
+              seed
+            });
+            const responseData = {
+              [paginationInfo.itemsFieldName]: result.items
+            };
+            if (paginationInfo.metaFields.includes("page")) {
+              responseData.page = result.page;
+            }
+            if (paginationInfo.metaFields.includes("totalPages")) {
+              responseData.totalPages = result.totalPages;
+            }
+            if (paginationInfo.metaFields.includes("total")) {
+              responseData.total = result.total;
+            }
+            if (paginationInfo.metaFields.includes("totalItems")) {
+              responseData.totalItems = result.total;
+            }
+            if (paginationInfo.metaFields.includes("limit")) {
+              responseData.limit = result.limit;
+            }
+            if (paginationInfo.metaFields.includes("size")) {
+              responseData.size = result.limit;
+            }
+            if (paginationInfo.metaFields.includes("offset")) {
+              responseData.offset = (result.page - 1) * result.limit;
+            }
+            mockData = responseData;
+          }
+        } else {
+          const numericSeed = hashString(seed);
+          const apiSchemas = c.api?.document?.components?.schemas;
+          const schemaContext = {
+            schemas: apiSchemas || cachedOpenAPISpec?.components?.schemas,
+            maxDepth: 10
+          };
+          mockData = generateMockFromSchema(
+            schema,
+            numericSeed,
+            schemaContext
+          );
+        }
       }
       return {
         statusCode: 200,
@@ -82,11 +189,14 @@ let pagePaginationManager = null;
 export function clearOpenApiCache() {
   apiInstance = null;
   cachedSpecPath = null;
+  cachedOpenAPISpec = null;
   cachedClientPackage = null;
   cachedClientPath = null;
   mockGenerator = null;
   cursorPaginationManager = null;
   pagePaginationManager = null;
+  specCursorManager = null;
+  specPageManager = null;
 }
 function getClientPackageData(packagePath, config, paginationConfig, cursorConfig) {
   if (cachedClientPackage && cachedClientPath === packagePath && mockGenerator && cursorPaginationManager && pagePaginationManager) {
@@ -146,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/handlers/rpc.d.ts

@@ -6,6 +6,6 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     success: boolean;
     service: string;
     method: string;
-    data: Record<string, unknown>;
+    data: unknown;
 }>>;
 export default _default;

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

@@ -4,9 +4,20 @@ import * as protoLoader from "@grpc/proto-loader";
 import * as grpc from "@grpc/grpc-js";
 import { readdirSync, statSync } from "node:fs";
 import { join, extname, dirname } from "pathe";
-import { generateMockMessage, deriveSeedFromRequest } from "../utils/mock/index.js";
+import {
+  generateMockMessage,
+  deriveSeedFromRequest,
+  CursorPaginationManager,
+  PagePaginationManager
+} from "../utils/mock/index.js";
+import {
+  ProtoItemProvider,
+  analyzeProtoPagination
+} from "../utils/mock/providers/index.js";
 let protoCache = null;
 let cachedProtoPath = null;
+let protoCursorManager = null;
+let protoPageManager = null;
 function findProtoFiles(dirPath) {
   const files = [];
   const stat = statSync(dirPath);
@@ -71,6 +82,8 @@ async function loadProto(protoPath) {
 export function clearProtoCache() {
   protoCache = null;
   cachedProtoPath = null;
+  protoCursorManager = null;
+  protoPageManager = null;
 }
 function getResponseTypeInfo(methodDef) {
   const responseType = methodDef.responseType;
@@ -130,13 +143,82 @@ export default defineEventHandler(async (event) => {
   }
   let requestBody;
   try {
-    requestBody = await readBody(event);
+    requestBody = await readBody(event) ?? {};
   } catch {
     requestBody = {};
   }
   const responseTypeInfo = getResponseTypeInfo(methodDef);
   const seed = deriveSeedFromRequest(requestBody);
-  const mockResponse = generateMockMessage(responseTypeInfo, seed);
+  const paginationInfo = analyzeProtoPagination(responseTypeInfo);
+  let mockResponse;
+  if (paginationInfo) {
+    const page = Number(requestBody.page) || 1;
+    const limit = Number(requestBody.limit) || Number(requestBody.page_size) || 20;
+    const cursor = requestBody.cursor;
+    const total = 100;
+    const itemProvider = new ProtoItemProvider(paginationInfo.itemMessageType, {
+      modelName: `${serviceName}.${methodName}`
+    });
+    if (!protoCursorManager) {
+      protoCursorManager = new CursorPaginationManager(itemProvider);
+    }
+    if (!protoPageManager) {
+      protoPageManager = new PagePaginationManager(itemProvider);
+    }
+    if (cursor || paginationInfo.isCursorBased) {
+      const result = protoCursorManager.getCursorPageWithProvider(itemProvider, {
+        cursor,
+        limit,
+        total,
+        seed
+      });
+      const responseData = {
+        [paginationInfo.itemsFieldName]: result.items
+      };
+      for (const metaField of paginationInfo.metaFields) {
+        const lowerField = metaField.toLowerCase();
+        if (lowerField.includes("next") && lowerField.includes("cursor")) {
+          responseData[metaField] = result.nextCursor;
+        } else if (lowerField.includes("prev") && lowerField.includes("cursor")) {
+          responseData[metaField] = result.prevCursor;
+        } else if (lowerField.includes("has_more") || lowerField.includes("hasmore")) {
+          responseData[metaField] = result.hasMore;
+        } else if (lowerField === "cursor") {
+          responseData[metaField] = result.nextCursor;
+        } else if (lowerField === "total" || lowerField === "total_items") {
+          responseData[metaField] = total;
+        }
+      }
+      mockResponse = responseData;
+    } else {
+      const result = protoPageManager.getPagedResponseWithProvider(itemProvider, {
+        page,
+        limit,
+        total,
+        seed
+      });
+      const responseData = {
+        [paginationInfo.itemsFieldName]: result.items
+      };
+      for (const metaField of paginationInfo.metaFields) {
+        const lowerField = metaField.toLowerCase();
+        if (lowerField === "page" || lowerField === "page_number") {
+          responseData[metaField] = result.page;
+        } else if (lowerField === "total_pages" || lowerField === "totalpages") {
+          responseData[metaField] = result.totalPages;
+        } else if (lowerField === "total" || lowerField === "total_items") {
+          responseData[metaField] = result.total;
+        } else if (lowerField === "limit" || lowerField === "page_size" || lowerField === "size") {
+          responseData[metaField] = result.limit;
+        } else if (lowerField === "offset") {
+          responseData[metaField] = (result.page - 1) * result.limit;
+        }
+      }
+      mockResponse = responseData;
+    }
+  } else {
+    mockResponse = generateMockMessage(responseTypeInfo, seed);
+  }
   return {
     success: true,
     service: serviceName,