mock-fried 1.3.1 → 1.4.1

package/dist/module.json

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

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

@@ -1,14 +1,10 @@
 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 인스턴스 가져오기 (캐싱 포함)
+ * Swagger 2.0과 OpenAPI 3.x 모두 지원
  */
 export declare function getOpenAPIBackend(specPath: string): Promise<any>;

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

@@ -1,5 +1,3 @@
-import { readFileSync } from "node:fs";
-import yaml from "js-yaml";
 import {
   generateMockFromSchema,
   hashString
@@ -10,12 +8,17 @@ import {
 } 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);
+import { loadSpec } from "../../utils/spec-loader.js";
+async function getCachedSpecLoader(specPath) {
+  const cache = cacheManager.specMode;
+  if (cache.specLoader && cache.specPath === specPath) {
+    return cache.specLoader;
   }
-  return JSON.parse(content);
+  const result = await loadSpec(specPath);
+  cache.specLoader = result;
+  cache.specPath = specPath;
+  console.log(`[mock-fried] Loaded ${result.version} spec: ${specPath}`);
+  return result;
 }
 export function resolveSchemaRef(schema, schemas) {
   if (!schema.$ref || !schemas) return schema;
@@ -29,13 +32,14 @@ export async function getOpenAPIBackend(specPath) {
     return cache.apiInstance;
   }
   const { OpenAPIBackend } = await import("openapi-backend");
-  const definition = loadOpenAPISpec(specPath);
-  cache.spec = definition;
+  const { spec, openapi3Spec } = await getCachedSpecLoader(specPath);
+  cache.spec = spec;
   const apiInstance = new OpenAPIBackend({
+    // OpenAPI 3.0 스펙 전달 (Swagger 2.0도 변환되어 사용)
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    definition,
-    quick: false,
-    // $ref 역참조를 위해 false로 설정
+    definition: openapi3Spec,
+    quick: true,
+    // 이미 OpenAPI 3.0으로 변환됨
     validate: false
     // Mock 서버에서는 request validation 비활성화
   });

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

@@ -2,11 +2,11 @@ import { defineEventHandler, createError } from "h3";
 import { useRuntimeConfig } from "#imports";
 import { consola } from "consola";
 import { createRequire } from "node:module";
-import { readFileSync, existsSync, statSync } from "node:fs";
-import yaml from "js-yaml";
+import { existsSync, statSync } from "node:fs";
 import { getClientPackage } from "../utils/client-parser.js";
 import { findProtoFiles, getProtoTypeName } from "../utils/proto-utils.js";
 import { cacheManager } from "../utils/cache-manager.js";
+import { loadSpec, getSchemaDefinitions, mergeParameters } from "../utils/spec-loader.js";
 const logger = consola.withTag("mock-fried");
 let _require = null;
 function getRequire() {
@@ -98,62 +98,25 @@ function parseClientPackageSchema(config) {
 export function clearSchemaCache() {
   cacheManager.clearSchema();
 }
-function parseOpenApiSpec(specPath) {
+async function parseOpenApiSpec(specPath) {
   if (!existsSync(specPath)) {
     return void 0;
   }
   try {
-    const content = readFileSync(specPath, "utf-8");
-    let spec;
-    if (specPath.endsWith(".yaml") || specPath.endsWith(".yml")) {
-      spec = yaml.load(content);
-    } else {
-      spec = JSON.parse(content);
-    }
+    const { spec, version } = await loadSpec(specPath);
     const info = spec.info || {};
     const paths = spec.paths || {};
     const pathItems = [];
     for (const [path, pathItem] of Object.entries(paths)) {
-      const pathLevelParams = [];
-      if (Array.isArray(pathItem.parameters)) {
-        for (const param of pathItem.parameters) {
-          const p = param;
-          pathLevelParams.push({
-            name: p.name,
-            in: p.in,
-            required: p.required,
-            description: p.description,
-            schema: p.schema
-          });
-        }
-      }
-      for (const [method, operation] of Object.entries(pathItem)) {
+      const pathObj = pathItem;
+      const pathLevelParams = extractParameters(pathObj.parameters);
+      for (const [method, operation] of Object.entries(pathObj)) {
         if (["get", "post", "put", "delete", "patch"].includes(method.toLowerCase())) {
           const op = operation;
-          const operationParams = [];
-          if (Array.isArray(op.parameters)) {
-            for (const param of op.parameters) {
-              const p = param;
-              operationParams.push({
-                name: p.name,
-                in: p.in,
-                required: p.required,
-                description: p.description,
-                schema: p.schema
-              });
-            }
-          }
-          const mergedParams = [...pathLevelParams];
-          for (const opParam of operationParams) {
-            const existingIndex = mergedParams.findIndex(
-              (p) => p.name === opParam.name && p.in === opParam.in
-            );
-            if (existingIndex >= 0) {
-              mergedParams[existingIndex] = opParam;
-            } else {
-              mergedParams.push(opParam);
-            }
-          }
+          const operationParams = extractParameters(op.parameters);
+          const mergedParams = mergeParameters(pathLevelParams, operationParams);
+          const requestBody = extractRequestBodyRef(op.requestBody);
+          const responses = extractResponsesRef(op.responses);
           pathItems.push({
             path,
             method: method.toUpperCase(),
@@ -162,25 +125,96 @@ function parseOpenApiSpec(specPath) {
             description: op.description,
             tags: op.tags,
             parameters: mergedParams.length > 0 ? mergedParams : void 0,
-            requestBody: op.requestBody,
-            responses: op.responses
+            requestBody,
+            responses
           });
         }
       }
     }
+    const schemas = getSchemaDefinitions(spec);
+    const schemaCount = Object.keys(schemas).length;
     return {
       info: {
         title: info.title || "Unknown API",
         version: info.version || "1.0.0",
         description: info.description
       },
-      paths: pathItems
+      paths: pathItems,
+      _meta: {
+        source: "spec-file",
+        specVersion: version,
+        // 'swagger2' | 'openapi3'
+        schemaCount,
+        endpointCount: pathItems.length
+      }
     };
   } catch (error) {
     logger.error("Failed to parse OpenAPI spec:", specPath, error);
     return void 0;
   }
 }
+function extractParameters(params) {
+  if (!Array.isArray(params)) return [];
+  return params.map((param) => {
+    const p = param;
+    return {
+      name: p.name,
+      in: p.in,
+      required: p.required,
+      description: p.description,
+      schema: p.schema
+    };
+  });
+}
+function extractRequestBodyRef(requestBody) {
+  if (!requestBody) return void 0;
+  const content = requestBody.content;
+  if (content?.["application/json"]?.schema) {
+    const schema = content["application/json"].schema;
+    return {
+      content: {
+        "application/json": {
+          schema: schema.$ref ? { $ref: schema.$ref } : { type: "object" }
+        }
+      }
+    };
+  }
+  return void 0;
+}
+function extractResponsesRef(responses) {
+  if (!responses) return void 0;
+  const result = {};
+  for (const [code, response] of Object.entries(responses)) {
+    const res = response;
+    const content = res.content;
+    if (content?.["application/json"]?.schema) {
+      const schema = content["application/json"].schema;
+      result[code] = {
+        description: res.description,
+        content: {
+          "application/json": {
+            schema: schema.$ref ? { $ref: schema.$ref } : { type: schema.type || "object" }
+          }
+        }
+      };
+    } else if (res.schema) {
+      const schema = res.schema;
+      result[code] = {
+        description: res.description,
+        content: {
+          "application/json": {
+            schema: schema.$ref ? { $ref: schema.$ref } : { type: schema.type || "object" }
+          }
+        }
+      };
+    } else {
+      result[code] = {
+        description: res.description
+      };
+    }
+  }
+  return result;
+}
 async function parseProtoSpec(protoPath) {
   if (!existsSync(protoPath)) {
     return void 0;
@@ -301,7 +335,7 @@ export default defineEventHandler(async () => {
       }
     };
   } else if (mockConfig.openapiPath) {
-    const openapi = parseOpenApiSpec(mockConfig.openapiPath);
+    const openapi = await parseOpenApiSpec(mockConfig.openapiPath);
     if (openapi) {
       schema.openapi = openapi;
     }

package/dist/runtime/server/utils/cache-manager.d.ts

@@ -7,6 +7,7 @@ import type { SchemaMockGenerator } from './mock/index.js';
 import type { CursorPaginationManager, PagePaginationManager } from './mock/pagination/index.js';
 import type * as protoLoader from '@grpc/proto-loader';
 import type * as grpc from '@grpc/grpc-js';
+import type { SpecLoaderResult } from './spec-loader.js';
 /**
  * OpenAPI 스펙 인터페이스
  */
@@ -33,6 +34,8 @@ interface SpecModeCache {
     apiInstance: any;
     specPath: string | null;
     spec: OpenAPISpec | null;
+    /** swagger-parser로 로드된 스펙 결과 (Swagger 2.0 지원) */
+    specLoader: SpecLoaderResult | null;
     cursorManager: CursorPaginationManager<Record<string, unknown>> | null;
     pageManager: PagePaginationManager<Record<string, unknown>> | null;
     backwardParam: string;

package/dist/runtime/server/utils/cache-manager.js

@@ -3,6 +3,7 @@ class MockCacheManager {
     apiInstance: null,
     specPath: null,
     spec: null,
+    specLoader: null,
     cursorManager: null,
     pageManager: null,
     backwardParam: "isBackward"
@@ -47,6 +48,7 @@ class MockCacheManager {
     this._specMode.apiInstance = null;
     this._specMode.specPath = null;
     this._specMode.spec = null;
+    this._specMode.specLoader = null;
     this._specMode.cursorManager = null;
     this._specMode.pageManager = null;
     this._specMode.backwardParam = "isBackward";

package/dist/runtime/server/utils/spec-loader.d.ts

@@ -0,0 +1,65 @@
+import type { OpenAPIV2, OpenAPIV3 } from 'openapi-types';
+export type ParsedSpec = OpenAPIV2.Document | OpenAPIV3.Document;
+export type SpecVersion = 'swagger2' | 'openapi3';
+export interface SpecLoaderResult {
+    /** 원본 스펙 (검증됨) */
+    spec: ParsedSpec;
+    /** 스펙 버전 */
+    version: SpecVersion;
+    /** $ref가 해석된 스펙 */
+    dereferenced: ParsedSpec;
+    /** OpenAPI 3.x로 변환된 스펙 (openapi-backend용) */
+    openapi3Spec: OpenAPIV3.Document;
+}
+/**
+ * OpenAPI/Swagger 스펙 파일 로드 및 파싱
+ *
+ * - $ref 해석 (dereference)
+ * - 버전 자동 감지
+ * - Swagger 2.0 → OpenAPI 3.0 변환
+ * - 검증
+ *
+ * @param specPath 스펙 파일 경로 (YAML/JSON)
+ */
+export declare function loadSpec(specPath: string): Promise<SpecLoaderResult>;
+/**
+ * Swagger 2.0 여부 확인
+ */
+export declare function isSwagger2(spec: ParsedSpec): spec is OpenAPIV2.Document;
+/**
+ * OpenAPI 3.x 여부 확인
+ */
+export declare function isOpenApi3(spec: ParsedSpec): spec is OpenAPIV3.Document;
+/**
+ * 스키마 정의 위치 가져오기 (버전별)
+ *
+ * - Swagger 2.0: definitions
+ * - OpenAPI 3.x: components/schemas
+ */
+export declare function getSchemaDefinitions(spec: ParsedSpec): Record<string, unknown>;
+/**
+ * 응답 스키마 추출 (버전별)
+ *
+ * 200 → 201 → 204 → default 순서로 찾음
+ *
+ * @param responses 응답 정의 객체
+ * @param spec 스펙 (버전 감지용)
+ */
+export declare function getResponseSchema(responses: OpenAPIV2.ResponsesObject | OpenAPIV3.ResponsesObject | undefined, spec: ParsedSpec): unknown | undefined;
+/**
+ * 파라미터 스키마 추출 (버전별)
+ *
+ * - Swagger 2.0: type 직접 또는 schema
+ * - OpenAPI 3.x: schema
+ */
+export declare function getParameterSchema(param: OpenAPIV2.ParameterObject | OpenAPIV3.ParameterObject, spec: ParsedSpec): unknown;
+/**
+ * path-level + operation-level 파라미터 병합
+ *
+ * operation-level이 path-level을 override (같은 name + in 조합)
+ */
+export declare function mergeParameters(pathParams: (OpenAPIV2.ParameterObject | OpenAPIV3.ParameterObject)[] | undefined, operationParams: (OpenAPIV2.ParameterObject | OpenAPIV3.ParameterObject)[] | undefined): (OpenAPIV2.ParameterObject | OpenAPIV3.ParameterObject)[];
+/**
+ * Swagger 2.0의 body 파라미터를 requestBody처럼 추출
+ */
+export declare function getRequestBodySchema(params: (OpenAPIV2.ParameterObject | OpenAPIV3.ParameterObject)[] | undefined, spec: ParsedSpec): unknown | undefined;

package/dist/runtime/server/utils/spec-loader.js

@@ -0,0 +1,100 @@
+import SwaggerParser from "@apidevtools/swagger-parser";
+export async function loadSpec(specPath) {
+  const spec = await SwaggerParser.parse(specPath);
+  const version = isSwagger2(spec) ? "swagger2" : "openapi3";
+  let openapi3Spec;
+  if (version === "swagger2") {
+    const { convertFile } = await import("swagger2openapi");
+    const result = await convertFile(specPath, {
+      patch: true,
+      // 자동 패치 적용
+      warnOnly: true
+      // 경고만 하고 계속 진행
+    });
+    openapi3Spec = result.openapi;
+  } else {
+    openapi3Spec = spec;
+  }
+  const dereferenced = await SwaggerParser.dereference(specPath);
+  return { spec, version, dereferenced, openapi3Spec };
+}
+export function isSwagger2(spec) {
+  return "swagger" in spec && spec.swagger === "2.0";
+}
+export function isOpenApi3(spec) {
+  return "openapi" in spec && (spec.openapi?.startsWith("3.") ?? false);
+}
+export function getSchemaDefinitions(spec) {
+  if (isSwagger2(spec)) {
+    return spec.definitions ?? {};
+  }
+  return spec.components?.schemas ?? {};
+}
+export function getResponseSchema(responses, spec) {
+  if (!responses) return void 0;
+  const successCodes = ["200", "201", "204", "default"];
+  for (const code of successCodes) {
+    const response = responses[code];
+    if (!response) continue;
+    if ("$ref" in response) continue;
+    if (isSwagger2(spec)) {
+      const swagger2Response = response;
+      if (swagger2Response.schema) {
+        return swagger2Response.schema;
+      }
+    } else {
+      const oas3Response = response;
+      const content = oas3Response.content;
+      if (content?.["application/json"]?.schema) {
+        return content["application/json"].schema;
+      }
+      if (content) {
+        const firstContentType = Object.keys(content)[0];
+        if (firstContentType && content[firstContentType]?.schema) {
+          return content[firstContentType].schema;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+export function getParameterSchema(param, spec) {
+  if (isSwagger2(spec)) {
+    const swagger2Param = param;
+    if ("schema" in swagger2Param && swagger2Param.schema) {
+      return swagger2Param.schema;
+    }
+    return {
+      type: swagger2Param.type,
+      format: swagger2Param.format,
+      enum: swagger2Param.enum,
+      minimum: swagger2Param.minimum,
+      maximum: swagger2Param.maximum,
+      default: swagger2Param.default
+    };
+  }
+  const oas3Param = param;
+  return oas3Param.schema;
+}
+export function mergeParameters(pathParams, operationParams) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const param of pathParams ?? []) {
+    const key = `${param.name}:${param.in}`;
+    merged.set(key, param);
+  }
+  for (const param of operationParams ?? []) {
+    const key = `${param.name}:${param.in}`;
+    merged.set(key, param);
+  }
+  return Array.from(merged.values());
+}
+export function getRequestBodySchema(params, spec) {
+  if (!params) return void 0;
+  if (isSwagger2(spec)) {
+    const bodyParam = params.find(
+      (p) => p.in === "body"
+    );
+    return bodyParam?.schema;
+  }
+  return void 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mock-fried",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Nuxt3 Mock API Module - OpenAPI & Protobuf RPC Mock Server",
   "repository": {
     "type": "git",
@@ -37,13 +37,15 @@
     "prepack": "nuxt-module-build build",
     "dev": "yarn dev:prepare && nuxi dev playground-openapi",
     "dev:openapi": "yarn dev:prepare && nuxi dev playground-openapi",
+    "dev:swagger": "yarn dev:prepare && nuxi dev playground-swagger",
     "dev:openapi-client": "yarn dev:prepare && nuxi dev playground-openapi-client",
     "dev:proto": "yarn dev:prepare:proto && nuxi dev playground-proto",
     "dev:build": "nuxi build playground-openapi",
+    "dev:build:swagger": "nuxi build playground-swagger",
     "dev:build:openapi-client": "nuxi build playground-openapi-client",
     "dev:build:proto": "nuxi build playground-proto",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare",
-    "dev:prepare:playground": "yarn dev:prepare && nuxi prepare playground-openapi && nuxi prepare playground-openapi-client && nuxi prepare playground-proto",
+    "dev:prepare:playground": "yarn dev:prepare && nuxi prepare playground-openapi && nuxi prepare playground-swagger && nuxi prepare playground-openapi-client && nuxi prepare playground-proto",
     "dev:prepare:proto": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground-proto",
     "release": "yarn lint && yarn test && yarn prepack && changelogen --release && yarn npm publish && git push --follow-tags",
     "lint": "eslint .",
@@ -56,33 +58,41 @@
     "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:swagger": "vitest run test/e2e/playground-swagger.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/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"
   },
+  "peerDependencies": {
+    "@nuxt/kit": ">=3.0.0"
+  },
   "dependencies": {
+    "@apidevtools/swagger-parser": "^12.1.0",
     "@grpc/grpc-js": "^1.12.0",
     "@grpc/proto-loader": "^0.7.13",
-    "@nuxt/kit": "^4.2.2",
     "consola": "^3.4.2",
     "js-yaml": "^4.1.0",
     "openapi-backend": "^5.10.6",
     "pathe": "^2.0.2",
+    "swagger2openapi": "^7.0.8",
     "ufo": "^1.6.1"
   },
   "devDependencies": {
     "@nuxt/devtools": "^3.1.1",
     "@nuxt/eslint-config": "^1.12.1",
+    "@nuxt/kit": "^4.2.2",
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "^4.2.2",
     "@nuxt/test-utils": "^3.21.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "latest",
+    "@types/swagger2openapi": "^7",
     "@vitest/coverage-v8": "^4.0.16",
     "changelogen": "^0.6.2",
     "eslint": "^9.39.2",
     "nuxt": "^4.2.2",
+    "openapi-types": "^12.1.3",
     "prettier": "^3.5.3",
     "typescript": "~5.9.3",
     "vitest": "^4.0.16",