mock-fried 1.0.0

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

@@ -0,0 +1,346 @@
+import { defineEventHandler, getQuery, readBody, createError, getRequestURL } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { readFileSync } from "node:fs";
+import yaml from "js-yaml";
+import {
+  generateMockFromSchema,
+  hashString,
+  SchemaMockGenerator,
+  extractDataModelName,
+  CursorPaginationManager,
+  PagePaginationManager
+} from "../utils/mock/index.js";
+import { getClientPackage } from "../utils/client-parser.js";
+let apiInstance = null;
+let cachedSpecPath = null;
+function loadOpenAPISpec(specPath) {
+  const content = readFileSync(specPath, "utf-8");
+  if (specPath.endsWith(".yaml") || specPath.endsWith(".yml")) {
+    return yaml.load(content);
+  }
+  return JSON.parse(content);
+}
+async function getOpenAPIBackend(specPath) {
+  if (apiInstance && cachedSpecPath === specPath) {
+    return apiInstance;
+  }
+  const { OpenAPIBackend } = await import("openapi-backend");
+  const definition = loadOpenAPISpec(specPath);
+  apiInstance = new OpenAPIBackend({
+    definition,
+    quick: true
+  });
+  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) => {
+      const operationId = c.operation?.operationId || "unknown";
+      const responses = c.operation?.responses;
+      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 seed = hashString(operationId + JSON.stringify(c.request?.params || {}));
+        mockData = generateMockFromSchema(jsonContent.schema, seed);
+      }
+      return {
+        statusCode: 200,
+        body: mockData,
+        meta: { operationId }
+      };
+    },
+    // 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();
+  cachedSpecPath = specPath;
+  return apiInstance;
+}
+let cachedClientPackage = null;
+let cachedClientPath = null;
+let mockGenerator = null;
+let cursorPaginationManager = null;
+let pagePaginationManager = null;
+function getClientPackageData(packagePath, config, paginationConfig, cursorConfig) {
+  if (cachedClientPackage && cachedClientPath === packagePath && mockGenerator && cursorPaginationManager && pagePaginationManager) {
+    return {
+      package: cachedClientPackage,
+      generator: mockGenerator,
+      cursorManager: cursorPaginationManager,
+      pageManager: pagePaginationManager
+    };
+  }
+  cachedClientPackage = getClientPackage(packagePath, config);
+  cachedClientPath = packagePath;
+  mockGenerator = new SchemaMockGenerator(cachedClientPackage.models);
+  cursorPaginationManager = new CursorPaginationManager(mockGenerator, {
+    cursorConfig
+  });
+  pagePaginationManager = new PagePaginationManager(mockGenerator, {
+    config: paginationConfig
+  });
+  return {
+    package: cachedClientPackage,
+    generator: mockGenerator,
+    cursorManager: cursorPaginationManager,
+    pageManager: pagePaginationManager
+  };
+}
+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;
+}
+function handleClientPackageRequest(pkg, generator, cursorManager, pageManager, path, method, query, _responseFormat = "auto") {
+  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;
+  const primitiveTypes = ["object", "string", "number", "boolean", "void", "any", "unknown"];
+  if (primitiveTypes.includes(endpoint.responseType.toLowerCase())) {
+    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
+      }
+    };
+  }
+  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 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) {
+      if (cursor) {
+        const result = cursorManager.getCursorPage(modelName, {
+          cursor,
+          limit,
+          total: 100,
+          seed
+        });
+        const { _snapshotId: _, ...responseWithoutSnapshotId } = result;
+        responseData = responseWithoutSnapshotId;
+      } else {
+        const result = pageManager.getPagedResponse(modelName, {
+          page,
+          limit,
+          total: 100,
+          seed
+        });
+        const { _snapshotId: _, ...responseWithoutSnapshotId } = result;
+        responseData = responseWithoutSnapshotId;
+      }
+    } else {
+      if (cursor) {
+        const result = cursorManager.getCursorPage(modelName, {
+          cursor,
+          limit,
+          total: 100,
+          seed
+        });
+        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;
+                } else if (field.name === "prevCursor") {
+                  otherFields[outputKey] = result.prevCursor;
+                } else if (field.name === "hasMore") {
+                  otherFields[outputKey] = result.hasMore;
+                } else if (field.name === "total" || field.name === "totalItems") {
+                  otherFields[outputKey] = 100;
+                }
+              }
+            }
+          }
+          responseData = {
+            [listJsonKey]: result.items,
+            ...otherFields
+          };
+        } else {
+          responseData = result.items;
+        }
+      } else {
+        const result = cursorManager.getCursorPage(modelName, {
+          limit,
+          total: 100,
+          seed
+        });
+        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;
+                } else if (field.name === "prevCursor") {
+                  otherFields[outputKey] = result.prevCursor;
+                } else if (field.name === "hasMore") {
+                  otherFields[outputKey] = result.hasMore;
+                } else if (field.name === "total" || field.name === "totalItems") {
+                  otherFields[outputKey] = 100;
+                }
+              }
+            }
+          }
+          responseData = {
+            [listJsonKey]: result.items,
+            ...otherFields
+          };
+        } else {
+          responseData = result.items;
+        }
+      }
+    }
+  } 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
+    }
+  };
+}
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig(event);
+  const mockConfig = config.mock;
+  const requestUrl = getRequestURL(event);
+  const prefix = mockConfig?.prefix || "/mock";
+  let path = requestUrl.pathname;
+  if (path.startsWith(prefix)) {
+    path = path.substring(prefix.length) || "/";
+  }
+  const query = getQuery(event);
+  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 result = handleClientPackageRequest(
+      pkg,
+      generator,
+      cursorManager,
+      pageManager,
+      path,
+      event.method,
+      query,
+      mockConfig.responseFormat ?? "auto"
+    );
+    if (result.statusCode) {
+      event.node.res.statusCode = result.statusCode;
+    }
+    return result.body;
+  }
+  if (mockConfig?.openapiPath) {
+    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/rpc.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    success: boolean;
+    service: string;
+    method: string;
+    data: Record<string, unknown>;
+}>>;
+export default _default;

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

@@ -0,0 +1,140 @@
+import { defineEventHandler, readBody, getRouterParams, createError } from "h3";
+import { useRuntimeConfig } from "#imports";
+import * as protoLoader from "@grpc/proto-loader";
+import * as grpc from "@grpc/grpc-js";
+import { readdirSync, statSync } from "node:fs";
+import { join, extname } from "pathe";
+import { generateMockMessage, deriveSeedFromRequest } from "../utils/mock/index.js";
+let protoCache = null;
+let cachedProtoPath = null;
+function findProtoFiles(dirPath) {
+  const files = [];
+  const stat = statSync(dirPath);
+  if (stat.isFile() && extname(dirPath) === ".proto") {
+    return [dirPath];
+  }
+  if (stat.isDirectory()) {
+    const entries = readdirSync(dirPath);
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry);
+      const entryStat = statSync(fullPath);
+      if (entryStat.isFile() && extname(entry) === ".proto") {
+        files.push(fullPath);
+      } else if (entryStat.isDirectory()) {
+        files.push(...findProtoFiles(fullPath));
+      }
+    }
+  }
+  return files;
+}
+function extractServices(obj, services, prefix = "") {
+  for (const [key, value] of Object.entries(obj)) {
+    const fullName = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "function" && "service" in value) {
+      const serviceConstructor = value;
+      services.set(key, serviceConstructor.service);
+      services.set(fullName, serviceConstructor.service);
+    } else if (typeof value === "object" && value !== null) {
+      extractServices(value, services, fullName);
+    }
+  }
+}
+async function loadProto(protoPath) {
+  if (protoCache && cachedProtoPath === protoPath) {
+    return protoCache;
+  }
+  const protoFiles = findProtoFiles(protoPath);
+  if (protoFiles.length === 0) {
+    throw new Error(`No .proto files found in ${protoPath}`);
+  }
+  const packageDefinition = await protoLoader.load(protoFiles, {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+    includeDirs: [protoPath]
+  });
+  const grpcObject = grpc.loadPackageDefinition(packageDefinition);
+  const services = /* @__PURE__ */ new Map();
+  extractServices(grpcObject, services);
+  protoCache = {
+    packageDefinition,
+    grpcObject,
+    services
+  };
+  cachedProtoPath = protoPath;
+  return protoCache;
+}
+function getResponseTypeInfo(methodDef) {
+  const responseType = methodDef.responseType;
+  if (responseType?.type) {
+    return responseType.type;
+  }
+  return {};
+}
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig(event);
+  const mockConfig = config.mock;
+  if (!mockConfig?.protoPath) {
+    throw createError({
+      statusCode: 500,
+      message: "Proto path not configured"
+    });
+  }
+  const params = getRouterParams(event);
+  const serviceName = params.service;
+  const methodName = params.method;
+  if (!serviceName || !methodName) {
+    throw createError({
+      statusCode: 400,
+      message: "Service and method are required"
+    });
+  }
+  let cache;
+  try {
+    cache = await loadProto(mockConfig.protoPath);
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      message: `Failed to load proto files: ${error instanceof Error ? error.message : "Unknown error"}`
+    });
+  }
+  const serviceDefinition = cache.services.get(serviceName);
+  if (!serviceDefinition) {
+    const availableServices = Array.from(cache.services.keys()).filter((k) => !k.includes("."));
+    throw createError({
+      statusCode: 404,
+      message: `Service '${serviceName}' not found. Available services: ${availableServices.join(", ")}`
+    });
+  }
+  const methodDef = serviceDefinition[methodName];
+  if (!methodDef) {
+    const availableMethods = Object.keys(serviceDefinition);
+    throw createError({
+      statusCode: 404,
+      message: `Method '${methodName}' not found in service '${serviceName}'. Available methods: ${availableMethods.join(", ")}`
+    });
+  }
+  if (methodDef.requestStream || methodDef.responseStream) {
+    throw createError({
+      statusCode: 501,
+      message: "Streaming methods are not supported. Only unary RPC is available."
+    });
+  }
+  let requestBody;
+  try {
+    requestBody = await readBody(event);
+  } catch {
+    requestBody = {};
+  }
+  const responseTypeInfo = getResponseTypeInfo(methodDef);
+  const seed = deriveSeedFromRequest(requestBody);
+  const mockResponse = generateMockMessage(responseTypeInfo, seed);
+  return {
+    success: true,
+    service: serviceName,
+    method: methodName,
+    data: mockResponse
+  };
+});

package/dist/runtime/server/handlers/schema.d.ts

@@ -0,0 +1,7 @@
+import type { ApiSchema } from '../../../types.js';
+/**
+ * 스키마 핸들러
+ * GET /mock/__schema
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<ApiSchema>>;
+export default _default;

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

@@ -0,0 +1,190 @@
+import { defineEventHandler, createError } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { readFileSync, existsSync } from "node:fs";
+let cachedSchema = null;
+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")) {
+      const yaml = require("js-yaml");
+      spec = yaml.load(content);
+    } else {
+      spec = JSON.parse(content);
+    }
+    const info = spec.info || {};
+    const paths = spec.paths || {};
+    const pathItems = [];
+    for (const [path, methods] of Object.entries(paths)) {
+      for (const [method, operation] of Object.entries(methods)) {
+        if (["get", "post", "put", "delete", "patch"].includes(method.toLowerCase())) {
+          const op = operation;
+          const parameters = [];
+          if (Array.isArray(op.parameters)) {
+            for (const param of op.parameters) {
+              const p = param;
+              parameters.push({
+                name: p.name,
+                in: p.in,
+                required: p.required,
+                description: p.description,
+                schema: p.schema
+              });
+            }
+          }
+          pathItems.push({
+            path,
+            method: method.toUpperCase(),
+            operationId: op.operationId,
+            summary: op.summary,
+            description: op.description,
+            tags: op.tags,
+            parameters: parameters.length > 0 ? parameters : void 0,
+            requestBody: op.requestBody,
+            responses: op.responses
+          });
+        }
+      }
+    }
+    return {
+      info: {
+        title: info.title || "Unknown API",
+        version: info.version || "1.0.0",
+        description: info.description
+      },
+      paths: pathItems
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function parseProtoSpec(protoPath) {
+  if (!existsSync(protoPath)) {
+    return void 0;
+  }
+  try {
+    const protoLoader = await import("@grpc/proto-loader");
+    const packageDefinition = await protoLoader.load(protoPath, {
+      keepCase: false,
+      longs: String,
+      enums: String,
+      defaults: true,
+      oneofs: true
+    });
+    const services = [];
+    let packageName;
+    for (const [fullName, def] of Object.entries(packageDefinition)) {
+      const definition = def;
+      if (!packageName && fullName.includes(".")) {
+        packageName = fullName.split(".").slice(0, -1).join(".");
+      }
+      if (!definition.format && typeof definition === "object") {
+        const methods = [];
+        for (const [methodName, methodDef] of Object.entries(definition)) {
+          const method = methodDef;
+          if (method.requestType && method.responseType) {
+            const reqType = method.requestType;
+            const resType = method.responseType;
+            const requestFields = extractFields(reqType);
+            const responseFields = extractFields(resType);
+            methods.push({
+              name: methodName,
+              requestType: reqType.name || "Unknown",
+              responseType: resType.name || "Unknown",
+              requestFields: requestFields.length > 0 ? requestFields : void 0,
+              responseFields: responseFields.length > 0 ? responseFields : void 0
+            });
+          }
+        }
+        if (methods.length > 0) {
+          const serviceName = fullName.split(".").pop() || fullName;
+          services.push({
+            name: serviceName,
+            methods
+          });
+        }
+      }
+    }
+    return {
+      package: packageName,
+      services
+    };
+  } catch {
+    return void 0;
+  }
+}
+function extractFields(messageType) {
+  const fields = [];
+  const typeObj = messageType.type;
+  if (typeObj && typeObj.field && Array.isArray(typeObj.field)) {
+    for (const field of typeObj.field) {
+      const f = field;
+      fields.push({
+        name: f.name,
+        type: getProtoTypeName(f.type, f.typeName),
+        repeated: f.label === 3,
+        // LABEL_REPEATED = 3
+        optional: f.label === 1
+        // LABEL_OPTIONAL = 1
+      });
+    }
+  }
+  return fields;
+}
+function getProtoTypeName(typeNum, typeName) {
+  const typeMap = {
+    1: "double",
+    2: "float",
+    3: "int64",
+    4: "uint64",
+    5: "int32",
+    6: "fixed64",
+    7: "fixed32",
+    8: "bool",
+    9: "string",
+    10: "group",
+    11: "message",
+    12: "bytes",
+    13: "uint32",
+    14: "enum",
+    15: "sfixed32",
+    16: "sfixed64",
+    17: "sint32",
+    18: "sint64"
+  };
+  if (typeName) {
+    return typeName.split(".").pop() || typeName;
+  }
+  return typeMap[typeNum] || "unknown";
+}
+export default defineEventHandler(async () => {
+  const config = useRuntimeConfig();
+  const mockConfig = config.mock;
+  if (cachedSchema) {
+    return cachedSchema;
+  }
+  const schema = {};
+  if (mockConfig.openapiPath) {
+    const openapi = parseOpenApiSpec(mockConfig.openapiPath);
+    if (openapi) {
+      schema.openapi = openapi;
+    }
+  }
+  if (mockConfig.protoPath) {
+    const rpc = await parseProtoSpec(mockConfig.protoPath);
+    if (rpc) {
+      schema.rpc = rpc;
+    }
+  }
+  if (!schema.openapi && !schema.rpc) {
+    throw createError({
+      statusCode: 404,
+      message: "No API schema available"
+    });
+  }
+  cachedSchema = schema;
+  return schema;
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}