mock-fried 1.2.1 → 1.3.1

package/dist/module.d.mts

@@ -49,6 +49,11 @@ interface MockCursorConfig {
      * @default false
      */
     includeSortInfo?: boolean;
+    /**
+     * 역방향 페이지네이션 쿼리 파라미터명
+     * @default 'isBackward'
+     */
+    backwardParam?: string;
 }
 /**
  * Mock Module Options

package/dist/module.json

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

package/dist/runtime/server/handlers/openapi/client-mode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OpenAPI Client Package Mode Handler
+ * Handles mock responses based on generated OpenAPI client packages
+ */
+import { SchemaMockGenerator, CursorPaginationManager, PagePaginationManager } from '../../utils/mock/index.js';
+import type { ParsedClientPackage, OpenApiClientConfig, MockPaginationConfig, MockCursorConfig } from '../../../../types.js';
+/**
+ * 클라이언트 패키지에서 파싱된 정보 가져오기 (캐싱 포함)
+ */
+export declare function getClientPackageData(packagePath: string, config?: OpenApiClientConfig, paginationConfig?: MockPaginationConfig, cursorConfig?: MockCursorConfig): {
+    package: ParsedClientPackage;
+    generator: SchemaMockGenerator;
+    cursorManager: CursorPaginationManager;
+    pageManager: PagePaginationManager;
+};
+/**
+ * 클라이언트 패키지 모드에서 Mock 응답 생성
+ */
+export declare function handleClientPackageRequest(pkg: ParsedClientPackage, generator: SchemaMockGenerator, cursorManager: CursorPaginationManager, pageManager: PagePaginationManager, path: string, method: string, query: Record<string, string | number>, backwardParam?: string): {
+    statusCode: number;
+    body: unknown;
+    meta?: Record<string, unknown>;
+};

package/dist/runtime/server/handlers/openapi/client-mode.js

@@ -0,0 +1,217 @@
+import {
+  SchemaMockGenerator,
+  extractDataModelName,
+  CursorPaginationManager,
+  PagePaginationManager
+} from "../../utils/mock/index.js";
+import { getClientPackage } from "../../utils/client-parser.js";
+import { cacheManager } from "../../utils/cache-manager.js";
+function getPathSpecificity(path) {
+  const segments = path.split("/").filter(Boolean);
+  const paramCount = (path.match(/\{(\w+)\}/g) || []).length;
+  return segments.length * 100 - paramCount * 10;
+}
+function findMatchingEndpoint(endpoints, path, method) {
+  const normalizedMethod = method.toUpperCase();
+  const sortedEndpoints = [...endpoints].filter((e) => e.method === normalizedMethod).sort((a, b) => getPathSpecificity(b.path) - getPathSpecificity(a.path));
+  for (const endpoint of sortedEndpoints) {
+    const pattern = endpoint.path.replace(/\{(\w+)\}/g, "([^/]+)");
+    const regex = new RegExp(`^${pattern}$`);
+    const match = path.match(regex);
+    if (match) {
+      const pathParams = {};
+      const paramNames = endpoint.path.match(/\{(\w+)\}/g) || [];
+      paramNames.forEach((param, index) => {
+        const paramName = param.slice(1, -1);
+        pathParams[paramName] = match[index + 1] || "";
+      });
+      return { endpoint, pathParams };
+    }
+  }
+  return null;
+}
+export function getClientPackageData(packagePath, config, paginationConfig, cursorConfig) {
+  const cache = cacheManager.clientMode;
+  if (cache.package && cache.path === packagePath && cache.generator && cache.cursorManager && cache.pageManager) {
+    return {
+      package: cache.package,
+      generator: cache.generator,
+      cursorManager: cache.cursorManager,
+      pageManager: cache.pageManager
+    };
+  }
+  cache.package = getClientPackage(packagePath, config);
+  cache.path = packagePath;
+  cache.generator = new SchemaMockGenerator(cache.package.models);
+  cache.cursorManager = new CursorPaginationManager(cache.generator, {
+    cursorConfig
+  });
+  cache.pageManager = new PagePaginationManager(cache.generator, {
+    config: paginationConfig
+  });
+  return {
+    package: cache.package,
+    generator: cache.generator,
+    cursorManager: cache.cursorManager,
+    pageManager: cache.pageManager
+  };
+}
+export function handleClientPackageRequest(pkg, generator, cursorManager, pageManager, path, method, query, backwardParam = "isBackward") {
+  const match = findMatchingEndpoint(pkg.endpoints, path, method);
+  if (!match) {
+    return {
+      statusCode: 404,
+      body: { error: "Not found", message: `No matching endpoint for ${method} ${path}` }
+    };
+  }
+  const { endpoint, pathParams } = match;
+  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())) {
+    return handlePrimitiveResponse(path, endpoint);
+  }
+  const typeInfo = extractDataModelName(endpoint.responseType, pkg.models);
+  const { modelName, isList, listFieldName, wrapperType } = typeInfo;
+  const page = Number(query.page) || 1;
+  const limit = Number(query.limit) || Number(query.size) || 20;
+  const cursor = query.cursor;
+  const isBackward = query[backwardParam] === "true" || query[backwardParam] === "1";
+  const wrapperSchema = wrapperType ? pkg.models.get(wrapperType) : null;
+  const hasItemsField = listFieldName === "items";
+  const hasPaginationFields = wrapperSchema?.fields.some(
+    (f) => ["page", "totalPages", "total", "totalItems", "pagination"].includes(f.name)
+  );
+  let responseData;
+  if (isList) {
+    const seed = `${endpoint.path}-${JSON.stringify(pathParams)}`;
+    if (hasItemsField && hasPaginationFields) {
+      responseData = handlePaginatedListResponse(
+        cursorManager,
+        pageManager,
+        modelName,
+        seed,
+        page,
+        limit,
+        cursor,
+        isBackward
+      );
+    } else {
+      responseData = handleSimpleListResponse(
+        cursorManager,
+        modelName,
+        seed,
+        limit,
+        cursor,
+        isBackward,
+        listFieldName,
+        wrapperSchema
+      );
+    }
+  } else {
+    const seed = `${endpoint.operationId}-${JSON.stringify(pathParams)}`;
+    responseData = generator.generateOne(endpoint.responseType, seed);
+  }
+  return {
+    statusCode: 200,
+    body: responseData,
+    meta: {
+      operationId: endpoint.operationId,
+      apiClass: endpoint.apiClassName,
+      responseType: endpoint.responseType
+    }
+  };
+}
+function handlePrimitiveResponse(path, endpoint) {
+  const pathLower = path.toLowerCase();
+  let primitiveResponse = {};
+  if (pathLower.includes("health")) {
+    primitiveResponse = { status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  } else if (pathLower.includes("ping")) {
+    primitiveResponse = { pong: true };
+  } else if (endpoint.responseType === "string") {
+    primitiveResponse = "success";
+  } else if (endpoint.responseType === "number") {
+    primitiveResponse = 0;
+  } else if (endpoint.responseType === "boolean") {
+    primitiveResponse = true;
+  }
+  return {
+    statusCode: 200,
+    body: primitiveResponse,
+    meta: {
+      operationId: endpoint.operationId,
+      apiClass: endpoint.apiClassName,
+      responseType: endpoint.responseType
+    }
+  };
+}
+function handlePaginatedListResponse(cursorManager, pageManager, modelName, seed, page, limit, cursor, isBackward) {
+  if (cursor || isBackward) {
+    const result = cursorManager.getCursorPage(modelName, {
+      cursor,
+      limit,
+      total: 100,
+      seed,
+      isBackward
+    });
+    const { _snapshotId: _, ...responseWithoutSnapshotId } = result;
+    return responseWithoutSnapshotId;
+  } else {
+    const result = pageManager.getPagedResponse(modelName, {
+      page,
+      limit,
+      total: 100,
+      seed
+    });
+    const { _snapshotId: _, ...responseWithoutSnapshotId } = result;
+    return responseWithoutSnapshotId;
+  }
+}
+function handleSimpleListResponse(cursorManager, modelName, seed, limit, cursor, isBackward, listFieldName, wrapperSchema) {
+  const result = cursorManager.getCursorPage(modelName, {
+    cursor,
+    limit,
+    total: 100,
+    seed,
+    isBackward
+  });
+  if (listFieldName) {
+    const listField = wrapperSchema?.fields.find((f) => f.name === listFieldName);
+    const listJsonKey = listField?.jsonKey || listFieldName;
+    const otherFields = {};
+    if (wrapperSchema) {
+      for (const field of wrapperSchema.fields) {
+        if (field.name !== listFieldName) {
+          const outputKey = field.jsonKey || field.name;
+          if (field.name === "nextCursor" || field.name === "cursor") {
+            otherFields[outputKey] = result.nextCursor ?? null;
+          } else if (field.name === "prevCursor") {
+            otherFields[outputKey] = result.prevCursor ?? null;
+          } else if (field.name === "hasMore") {
+            otherFields[outputKey] = result.hasMore;
+          } else if (field.name === "hasPrev") {
+            otherFields[outputKey] = result.hasPrev ?? false;
+          } else if (field.name === "total" || field.name === "totalItems") {
+            otherFields[outputKey] = 100;
+          }
+        }
+      }
+    }
+    return {
+      [listJsonKey]: result.items,
+      ...otherFields
+    };
+  } else {
+    return result.items;
+  }
+}

package/dist/runtime/server/handlers/{openapi.d.ts → openapi/index.d.ts}

@@ -2,5 +2,8 @@
  * OpenAPI 관련 캐시 초기화
  */
 export declare function clearOpenApiCache(): void;
+/**
+ * OpenAPI Mock 핸들러
+ */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;

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

@@ -0,0 +1,79 @@
+import { defineEventHandler, readBody, createError } from "h3";
+import { parseQuery } from "ufo";
+import { useRuntimeConfig } from "#imports";
+import { cacheManager } from "../../utils/cache-manager.js";
+import { getOpenAPIBackend } from "./spec-mode.js";
+import { getClientPackageData, handleClientPackageRequest } from "./client-mode.js";
+export function clearOpenApiCache() {
+  cacheManager.clearOpenApi();
+}
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig(event);
+  const mockConfig = config.mock;
+  const prefix = mockConfig?.prefix || "/mock";
+  const fullPath = event.path;
+  const queryIndex = fullPath.indexOf("?");
+  let path = queryIndex >= 0 ? fullPath.substring(0, queryIndex) : fullPath;
+  const queryString = queryIndex >= 0 ? fullPath.substring(queryIndex + 1) : "";
+  if (path.startsWith(prefix)) {
+    path = path.substring(prefix.length) || "/";
+  }
+  const query = parseQuery(queryString);
+  let body;
+  if (event.method !== "GET" && event.method !== "HEAD") {
+    try {
+      body = await readBody(event);
+    } catch {
+      body = void 0;
+    }
+  }
+  if (mockConfig?.clientPackagePath) {
+    const { package: pkg, generator, cursorManager, pageManager } = getClientPackageData(
+      mockConfig.clientPackagePath,
+      mockConfig.clientPackageConfig,
+      mockConfig.pagination,
+      mockConfig.cursor
+    );
+    const backwardParam = mockConfig?.cursor?.backwardParam || "isBackward";
+    const result = handleClientPackageRequest(
+      pkg,
+      generator,
+      cursorManager,
+      pageManager,
+      path,
+      event.method,
+      query,
+      backwardParam
+    );
+    if (result.statusCode) {
+      event.node.res.statusCode = result.statusCode;
+    }
+    return result.body;
+  }
+  if (mockConfig?.openapiPath) {
+    cacheManager.specMode.backwardParam = mockConfig?.cursor?.backwardParam || "isBackward";
+    const backend = await getOpenAPIBackend(mockConfig.openapiPath);
+    const headers = {};
+    const rawHeaders = event.headers;
+    if (rawHeaders) {
+      for (const [key, value] of Object.entries(rawHeaders)) {
+        if (value) headers[key] = String(value);
+      }
+    }
+    const result = await backend.handleRequest({
+      method: event.method,
+      path,
+      query,
+      body,
+      headers
+    });
+    if (result?.statusCode) {
+      event.node.res.statusCode = result.statusCode;
+    }
+    return result?.body ?? result;
+  }
+  throw createError({
+    statusCode: 500,
+    message: "OpenAPI configuration not found. Set openapi path or client package."
+  });
+});

package/dist/runtime/server/handlers/openapi/spec-mode.d.ts

@@ -0,0 +1,14 @@
+import { type OpenAPISchema } from '../../utils/mock/providers/index.js';
+import { type OpenAPISpec } from '../../utils/cache-manager.js';
+/**
+ * OpenAPI 스펙 파일 로드
+ */
+export declare function loadOpenAPISpec(specPath: string): OpenAPISpec;
+/**
+ * 스키마 참조 해결
+ */
+export declare function resolveSchemaRef(schema: OpenAPISchema, schemas?: Record<string, Record<string, unknown>>): OpenAPISchema;
+/**
+ * OpenAPI Backend 인스턴스 가져오기 (캐싱 포함)
+ */
+export declare function getOpenAPIBackend(specPath: string): Promise<any>;

package/dist/runtime/server/handlers/openapi/spec-mode.js

@@ -0,0 +1,198 @@
+import { readFileSync } from "node:fs";
+import yaml from "js-yaml";
+import {
+  generateMockFromSchema,
+  hashString
+} from "../../utils/mock/index.js";
+import {
+  OpenAPIItemProvider,
+  analyzePaginationSchema
+} from "../../utils/mock/providers/index.js";
+import { cacheManager } from "../../utils/cache-manager.js";
+import { getOrCreateCursorManager, getOrCreatePageManager } from "../../utils/pagination-factory.js";
+export function loadOpenAPISpec(specPath) {
+  const content = readFileSync(specPath, "utf-8");
+  if (specPath.endsWith(".yaml") || specPath.endsWith(".yml")) {
+    return yaml.load(content);
+  }
+  return JSON.parse(content);
+}
+export function resolveSchemaRef(schema, schemas) {
+  if (!schema.$ref || !schemas) return schema;
+  const schemaName = schema.$ref.split("/").pop();
+  const resolved = schemaName ? schemas[schemaName] : void 0;
+  return resolved ?? schema;
+}
+export async function getOpenAPIBackend(specPath) {
+  const cache = cacheManager.specMode;
+  if (cache.apiInstance && cache.specPath === specPath) {
+    return cache.apiInstance;
+  }
+  const { OpenAPIBackend } = await import("openapi-backend");
+  const definition = loadOpenAPISpec(specPath);
+  cache.spec = definition;
+  const apiInstance = new OpenAPIBackend({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    definition,
+    quick: false,
+    // $ref 역참조를 위해 false로 설정
+    validate: false
+    // Mock 서버에서는 request validation 비활성화
+  });
+  apiInstance.register({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    notFound: async (_c) => {
+      return {
+        statusCode: 404,
+        body: { error: "Not found", message: "No matching operation found" }
+      };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    notImplemented: async (c) => {
+      return handleNotImplemented(c, cache);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    validationFail: async (c) => {
+      return {
+        statusCode: 400,
+        body: {
+          error: "Validation failed",
+          details: c.validation?.errors || []
+        }
+      };
+    }
+  });
+  await apiInstance.init();
+  cache.apiInstance = apiInstance;
+  cache.specPath = specPath;
+  return apiInstance;
+}
+async function handleNotImplemented(c, cache) {
+  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"];
+  let mockData = null;
+  if (jsonContent?.example) {
+    mockData = jsonContent.example;
+  } else if (jsonContent?.schema) {
+    const schema = jsonContent.schema;
+    const seed = `${operationId}-${JSON.stringify(c.request?.params || {})}`;
+    const apiSchemas = c.api?.document?.components?.schemas;
+    const schemaContext = {
+      schemas: apiSchemas || cache.spec?.components?.schemas,
+      maxDepth: 10
+    };
+    const resolvedSchema = resolveSchemaRef(schema, schemaContext.schemas);
+    const paginationInfo = analyzePaginationSchema(resolvedSchema);
+    if (paginationInfo) {
+      mockData = handlePaginationResponse(c, cache, paginationInfo, seed, schemaContext, operationId);
+    } else {
+      const numericSeed = hashString(seed);
+      mockData = generateMockFromSchema(
+        schema,
+        numericSeed,
+        schemaContext
+      );
+    }
+  }
+  return {
+    statusCode: 200,
+    body: mockData,
+    meta: { operationId }
+  };
+}
+function handlePaginationResponse(c, cache, paginationInfo, seed, schemaContext, operationId) {
+  if (!paginationInfo) {
+    return {};
+  }
+  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 isBackward = query[cache.backwardParam] === "true" || query[cache.backwardParam] === "1";
+  const total = 100;
+  const itemProvider = new OpenAPIItemProvider(paginationInfo.itemSchema, {
+    modelName: operationId,
+    schemaContext
+  });
+  const cursorManager = getOrCreateCursorManager(itemProvider, cache);
+  const pageManager = getOrCreatePageManager(itemProvider, cache);
+  if (cursor || isBackward || paginationInfo.isCursorBased) {
+    const result = cursorManager.getCursorPageWithProvider(itemProvider, {
+      cursor,
+      limit,
+      total,
+      seed,
+      isBackward
+    });
+    return buildCursorResponse(result, paginationInfo, total);
+  } else {
+    const result = pageManager.getPagedResponseWithProvider(itemProvider, {
+      page,
+      limit,
+      total,
+      seed
+    });
+    return buildPageResponse(result, paginationInfo);
+  }
+}
+function buildCursorResponse(result, paginationInfo, total) {
+  const responseData = {
+    [paginationInfo.itemsFieldName]: result.items
+  };
+  if (paginationInfo.metaFields.includes("nextCursor")) {
+    responseData.nextCursor = result.nextCursor ?? null;
+  }
+  if (paginationInfo.metaFields.includes("prevCursor")) {
+    responseData.prevCursor = result.prevCursor ?? null;
+  }
+  if (paginationInfo.metaFields.includes("hasMore")) {
+    responseData.hasMore = result.hasMore;
+  }
+  if (paginationInfo.metaFields.includes("hasPrev")) {
+    responseData.hasPrev = result.hasPrev ?? false;
+  }
+  if (paginationInfo.metaFields.includes("total")) {
+    responseData.total = total;
+  }
+  if (paginationInfo.metaFields.includes("cursor")) {
+    responseData.cursor = result.nextCursor ?? null;
+  }
+  return responseData;
+}
+function buildPageResponse(result, paginationInfo) {
+  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;
+  }
+  return responseData;
+}

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

@@ -1,5 +1,5 @@
 import { defineEventHandler } from "h3";
-import { clearOpenApiCache } from "./openapi.js";
+import { clearOpenApiCache } from "./openapi/index.js";
 import { clearProtoCache } from "./rpc.js";
 import { clearSchemaCache } from "./schema.js";
 import { clearClientPackageCache } from "../utils/client-parser.js";