@gomjellie/lazyapi 0.0.1

package/dist/services/http-client.js

@@ -0,0 +1,173 @@
+/**
+ * HTTP 클라이언트 서비스
+ */
+import axios from 'axios';
+export class HttpClientService {
+    client;
+    constructor(baseURL) {
+        this.client = axios.create({
+            baseURL,
+            timeout: 30000,
+            validateStatus: () => true, // 모든 상태 코드를 허용
+        });
+    }
+    /**
+     * API 요청 실행
+     */
+    async executeRequest(endpoint, parameterValues, headers, requestBody, baseURL) {
+        const startTime = Date.now();
+        try {
+            // URL 빌드 (path parameters 치환)
+            let url = endpoint.path;
+            const pathParams = endpoint.parameters.filter((p) => p.in === 'path');
+            for (const param of pathParams) {
+                const value = parameterValues[param.name] || '';
+                url = url.replace(`{${param.name}}`, encodeURIComponent(value));
+            }
+            // Query parameters 빌드
+            const queryParams = endpoint.parameters.filter((p) => p.in === 'query');
+            const params = {};
+            for (const param of queryParams) {
+                const value = parameterValues[param.name];
+                if (value !== undefined && value !== '') {
+                    params[param.name] = value;
+                }
+            }
+            // Headers 빌드
+            const headerParams = endpoint.parameters.filter((p) => p.in === 'header');
+            const requestHeaders = { ...headers };
+            for (const param of headerParams) {
+                const value = parameterValues[param.name];
+                if (value !== undefined && value !== '') {
+                    requestHeaders[param.name] = value;
+                }
+            }
+            // Request body 파싱
+            let data;
+            if (requestBody && requestBody.trim()) {
+                try {
+                    data = JSON.parse(requestBody);
+                    requestHeaders['Content-Type'] = 'application/json';
+                }
+                catch {
+                    // JSON 파싱 실패시 문자열로 전송
+                    data = requestBody;
+                }
+            }
+            // Axios 요청 설정
+            const config = {
+                method: endpoint.method.toLowerCase(),
+                url,
+                params,
+                headers: requestHeaders,
+                data,
+            };
+            // baseURL이 제공된 경우 사용
+            if (baseURL) {
+                config.baseURL = baseURL;
+            }
+            // 요청 실행
+            const response = await this.client.request(config);
+            const duration = Date.now() - startTime;
+            // 응답 크기 계산
+            const responseString = JSON.stringify(response.data);
+            const size = new Blob([responseString]).size;
+            // AxiosHeaders를 일반 객체로 변환
+            // AxiosHeaders 객체가 화면에 표시되지 않도록 일반 객체로 변환
+            // JSON 직렬화/역직렬화를 통해 순수 객체로 변환
+            const responseHeaders = {};
+            if (response.headers) {
+                try {
+                    // AxiosHeaders를 일반 객체로 변환
+                    const headersObj = JSON.parse(JSON.stringify(response.headers));
+                    for (const key in headersObj) {
+                        if (Object.prototype.hasOwnProperty.call(headersObj, key)) {
+                            const value = headersObj[key];
+                            // 값이 문자열이거나 변환 가능한 경우만 추가
+                            if (typeof value === 'string') {
+                                responseHeaders[key] = value;
+                            }
+                            else if (Array.isArray(value)) {
+                                // 배열인 경우 첫 번째 요소 사용 (일반적으로 헤더는 단일 값)
+                                responseHeaders[key] = String(value[0] || '');
+                            }
+                            else if (value != null) {
+                                responseHeaders[key] = String(value);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // JSON 변환 실패 시 직접 순회
+                    const headersObj = response.headers;
+                    for (const key in headersObj) {
+                        if (Object.prototype.hasOwnProperty.call(headersObj, key)) {
+                            const value = headersObj[key];
+                            if (typeof value === 'string') {
+                                responseHeaders[key] = value;
+                            }
+                            else if (Array.isArray(value)) {
+                                responseHeaders[key] = String(value[0] || '');
+                            }
+                            else if (value != null) {
+                                responseHeaders[key] = String(value);
+                            }
+                        }
+                    }
+                }
+            }
+            // Cookies 추출
+            const cookies = {};
+            const setCookieHeader = responseHeaders['set-cookie'];
+            if (setCookieHeader) {
+                const cookieArray = Array.isArray(setCookieHeader) ? setCookieHeader : [setCookieHeader];
+                for (const cookie of cookieArray) {
+                    const [nameValue] = cookie.split(';');
+                    const [name, value] = nameValue.split('=');
+                    if (name && value) {
+                        cookies[name.trim()] = value.trim();
+                    }
+                }
+            }
+            return {
+                status: response.status,
+                statusText: response.statusText,
+                headers: responseHeaders,
+                body: response.data,
+                size,
+                duration,
+                cookies: Object.keys(cookies).length > 0 ? cookies : undefined,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            if (axios.isAxiosError(error)) {
+                // 네트워크 에러 또는 타임아웃
+                return {
+                    status: 0,
+                    statusText: error.message,
+                    headers: {},
+                    body: { error: error.message, code: error.code },
+                    size: 0,
+                    duration,
+                };
+            }
+            throw error;
+        }
+    }
+    /**
+     * 기본 URL 설정
+     */
+    setBaseURL(baseURL) {
+        this.client.defaults.baseURL = baseURL;
+    }
+    /**
+     * 기본 헤더 설정
+     */
+    setDefaultHeaders(headers) {
+        this.client.defaults.headers.common = {
+            ...this.client.defaults.headers.common,
+            ...headers,
+        };
+    }
+}

package/dist/services/openapi-parser.d.ts

@@ -0,0 +1,47 @@
+/**
+ * OpenAPI 문서 파싱 서비스
+ */
+import { OpenAPIDocument, Endpoint, HttpMethod } from '../types/openapi.js';
+import type { OpenAPI } from 'openapi-types';
+export declare class OpenAPIParserService {
+    /**
+     * OpenAPI 문서를 파일에서 로드하고 파싱
+     */
+    parseFromFile(filePath: string): Promise<OpenAPI.Document>;
+    /**
+     * OpenAPI 문서에서 엔드포인트 목록 추출
+     */
+    extractEndpoints(document: OpenAPIDocument): Endpoint[];
+    /**
+     * OpenAPI v3 Operation 객체에서 Endpoint 생성
+     */
+    private createEndpointV3;
+    /**
+     * Swagger 2.0 Operation 객체에서 Endpoint 생성
+     */
+    private createEndpointV2;
+    /**
+     * OpenAPI v3 파라미터를 정규화
+     */
+    private normalizeParameterV3;
+    /**
+     * Swagger 2.0 파라미터를 정규화
+     */
+    private normalizeParameterV2;
+    /**
+     * OpenAPI v3 RequestBody를 정규화
+     */
+    private normalizeRequestBodyV3;
+    /**
+     * 엔드포인트 필터링
+     */
+    filterEndpoints(endpoints: Endpoint[], method: HttpMethod | 'ALL'): Endpoint[];
+    /**
+     * 엔드포인트 검색
+     */
+    searchEndpoints(endpoints: Endpoint[], query: string): Endpoint[];
+    /**
+     * 태그별로 엔드포인트 그룹화
+     */
+    groupByTags(endpoints: Endpoint[]): Map<string, Endpoint[]>;
+}

package/dist/services/openapi-parser.js

@@ -0,0 +1,318 @@
+/**
+ * OpenAPI 문서 파싱 서비스
+ */
+import SwaggerParser from '@apidevtools/swagger-parser';
+import fs from 'fs';
+import path from 'path';
+import { isOpenAPIV2Document, isReferenceObject, resolveRef, } from '../types/openapi.js';
+export class OpenAPIParserService {
+    /**
+     * OpenAPI 문서를 파일에서 로드하고 파싱
+     */
+    async parseFromFile(filePath) {
+        try {
+            // 파일 존재 확인
+            if (!fs.existsSync(filePath)) {
+                throw new Error(`파일을 찾을 수 없습니다: ${filePath}`);
+            }
+            // 파일 확장자 확인
+            const ext = path.extname(filePath).toLowerCase();
+            if (!['.json', '.yaml', '.yml'].includes(ext)) {
+                throw new Error('지원하지 않는 파일 형식입니다. JSON 또는 YAML 파일만 지원합니다.');
+            }
+            // SwaggerParser로 문서 파싱
+            // bundle()을 사용하여 $ref를 내부 참조로 유지하면서 외부 파일만 번들링
+            // validate()는 모든 $ref를 resolve하므로 사용하지 않음
+            const api = await SwaggerParser.bundle(filePath);
+            return api;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`OpenAPI 문서 파싱 실패: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * OpenAPI 문서에서 엔드포인트 목록 추출
+     */
+    extractEndpoints(document) {
+        const endpoints = [];
+        if (!document.paths) {
+            return endpoints;
+        }
+        const isV2 = isOpenAPIV2Document(document);
+        if (isV2) {
+            // Swagger 2.0 처리
+            const v2Doc = document;
+            for (const [path, pathItem] of Object.entries(v2Doc.paths)) {
+                if (!pathItem)
+                    continue;
+                const methods = [
+                    'get',
+                    'post',
+                    'put',
+                    'delete',
+                    'patch',
+                    'options',
+                    'head',
+                    'trace',
+                ];
+                for (const method of methods) {
+                    const operation = pathItem[method];
+                    if (operation) {
+                        endpoints.push(this.createEndpointV2(path, method.toUpperCase(), operation, pathItem));
+                    }
+                }
+            }
+        }
+        else {
+            // OpenAPI 3.x 처리
+            const v3Doc = document;
+            for (const [path, pathItem] of Object.entries(v3Doc.paths)) {
+                if (!pathItem)
+                    continue;
+                const methods = [
+                    'get',
+                    'post',
+                    'put',
+                    'delete',
+                    'patch',
+                    'options',
+                    'head',
+                    'trace',
+                ];
+                for (const method of methods) {
+                    const operation = pathItem[method];
+                    if (operation) {
+                        endpoints.push(this.createEndpointV3(path, method.toUpperCase(), operation, pathItem, document));
+                    }
+                }
+            }
+        }
+        return endpoints;
+    }
+    /**
+     * OpenAPI v3 Operation 객체에서 Endpoint 생성
+     */
+    createEndpointV3(path, method, operation, pathItem, document) {
+        const id = `${method}_${path.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        // 파라미터 병합 및 정규화
+        const pathParameters = pathItem.parameters || [];
+        const operationParameters = operation.parameters || [];
+        const allParams = [...pathParameters, ...operationParameters];
+        const parameters = allParams
+            .filter((p) => !isReferenceObject(p))
+            .map((p) => this.normalizeParameterV3(p));
+        // RequestBody 정규화
+        let requestBody;
+        if (operation.requestBody) {
+            if (isReferenceObject(operation.requestBody)) {
+                // $ref를 resolve
+                if (document) {
+                    const resolved = resolveRef(operation.requestBody.$ref, document);
+                    if (resolved && !isReferenceObject(resolved)) {
+                        requestBody = this.normalizeRequestBodyV3(resolved);
+                    }
+                }
+            }
+            else {
+                requestBody = this.normalizeRequestBodyV3(operation.requestBody);
+            }
+        }
+        return {
+            id,
+            method,
+            path,
+            summary: operation.summary,
+            description: operation.description ?? pathItem.description,
+            tags: operation.tags || [],
+            parameters,
+            requestBody,
+            responses: operation.responses || {},
+            operationId: operation.operationId,
+            deprecated: operation.deprecated,
+            security: operation.security,
+        };
+    }
+    /**
+     * Swagger 2.0 Operation 객체에서 Endpoint 생성
+     */
+    createEndpointV2(path, method, operation, pathItem) {
+        const id = `${method}_${path.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        // 파라미터 병합 및 정규화
+        const pathParameters = pathItem.parameters || [];
+        const operationParameters = operation.parameters || [];
+        const allParams = [...pathParameters, ...operationParameters];
+        const parameters = [];
+        let requestBody;
+        for (const p of allParams) {
+            if (isReferenceObject(p))
+                continue;
+            const param = p;
+            // Swagger 2.0의 body 파라미터 처리
+            if (param.in === 'body') {
+                const bodyParam = param;
+                // requestBody로도 저장
+                requestBody = {
+                    description: bodyParam.description,
+                    required: bodyParam.required,
+                    schema: bodyParam.schema,
+                };
+                // UI 표시를 위해 parameters에도 포함
+                parameters.push(this.normalizeParameterV2(param));
+            }
+            else {
+                // 나머지 파라미터들 (path, query, header, formData)
+                parameters.push(this.normalizeParameterV2(param));
+            }
+        }
+        return {
+            id,
+            method,
+            path,
+            summary: operation.summary,
+            description: operation.description,
+            tags: operation.tags || [],
+            parameters,
+            requestBody,
+            responses: operation.responses || {},
+            operationId: operation.operationId,
+            deprecated: operation.deprecated,
+            security: operation.security,
+        };
+    }
+    /**
+     * OpenAPI v3 파라미터를 정규화
+     */
+    normalizeParameterV3(param) {
+        return {
+            name: param.name,
+            in: param.in,
+            description: param.description,
+            required: param.required,
+            deprecated: param.deprecated,
+            schema: isReferenceObject(param.schema) ? undefined : param.schema,
+        };
+    }
+    /**
+     * Swagger 2.0 파라미터를 정규화
+     */
+    normalizeParameterV2(param) {
+        // body 파라미터는 이미 schema를 가지고 있음 ($ref도 포함)
+        if (param.in === 'body') {
+            const bodyParam = param;
+            return {
+                name: bodyParam.name,
+                in: bodyParam.in,
+                description: bodyParam.description,
+                required: bodyParam.required,
+                schema: bodyParam.schema, // $ref인 경우도 그대로 전달
+            };
+        }
+        // 일반 파라미터: type, items, enum 등을 schema로 변환
+        const generalParam = param;
+        // Swagger 2.0의 파라미터 속성들을 SchemaObject로 변환
+        const schema = {
+            type: generalParam.type,
+            format: generalParam.format,
+            items: generalParam.items,
+            default: generalParam.default,
+            maximum: generalParam.maximum,
+            exclusiveMaximum: generalParam.exclusiveMaximum,
+            minimum: generalParam.minimum,
+            exclusiveMinimum: generalParam.exclusiveMinimum,
+            maxLength: generalParam.maxLength,
+            minLength: generalParam.minLength,
+            pattern: generalParam.pattern,
+            maxItems: generalParam.maxItems,
+            minItems: generalParam.minItems,
+            uniqueItems: generalParam.uniqueItems,
+            enum: generalParam.enum,
+            multipleOf: generalParam.multipleOf,
+        };
+        // undefined 속성 제거
+        Object.keys(schema).forEach((key) => {
+            if (schema[key] === undefined) {
+                delete schema[key];
+            }
+        });
+        return {
+            name: generalParam.name,
+            in: generalParam.in,
+            description: generalParam.description,
+            required: generalParam.required,
+            schema: Object.keys(schema).length > 0 ? schema : undefined,
+            type: generalParam.type,
+            format: generalParam.format,
+            enum: generalParam.enum,
+            default: generalParam.default,
+        };
+    }
+    /**
+     * OpenAPI v3 RequestBody를 정규화
+     */
+    normalizeRequestBodyV3(requestBody) {
+        // application/json 스키마 우선 추출
+        const jsonContent = requestBody.content?.['application/json'];
+        const schema = jsonContent && !isReferenceObject(jsonContent.schema) ? jsonContent.schema : undefined;
+        return {
+            description: requestBody.description,
+            required: requestBody.required,
+            schema,
+        };
+    }
+    /**
+     * 엔드포인트 필터링
+     */
+    filterEndpoints(endpoints, method) {
+        if (method === 'ALL') {
+            return endpoints;
+        }
+        return endpoints.filter((endpoint) => endpoint.method === method);
+    }
+    /**
+     * 엔드포인트 검색
+     */
+    searchEndpoints(endpoints, query) {
+        if (!query.trim()) {
+            return endpoints;
+        }
+        const lowerQuery = query.toLowerCase();
+        return endpoints.filter((endpoint) => {
+            // 경로, 요약, 설명, 태그에서 검색
+            const searchableText = [
+                endpoint.path,
+                endpoint.summary || '',
+                endpoint.description || '',
+                ...endpoint.tags,
+            ]
+                .join(' ')
+                .toLowerCase();
+            return searchableText.includes(lowerQuery);
+        });
+    }
+    /**
+     * 태그별로 엔드포인트 그룹화
+     */
+    groupByTags(endpoints) {
+        const groups = new Map();
+        for (const endpoint of endpoints) {
+            if (endpoint.tags.length === 0) {
+                // 태그가 없는 경우 'default'로 분류
+                const defaultGroup = groups.get('default') || [];
+                defaultGroup.push(endpoint);
+                groups.set('default', defaultGroup);
+            }
+            else {
+                // 각 태그에 추가
+                for (const tag of endpoint.tags) {
+                    const group = groups.get(tag) || [];
+                    group.push(endpoint);
+                    groups.set(tag, group);
+                }
+            }
+        }
+        return groups;
+    }
+}

package/dist/store/appSlice.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 애플리케이션 Redux Slice
+ */
+import { AppState, AppMode, Screen, ApiResponse } from '../types/app-state.js';
+import { Endpoint, HttpMethod, OpenAPIDocument } from '../types/openapi.js';
+export declare const setDocument: import("@reduxjs/toolkit").ActionCreatorWithPayload<OpenAPIDocument, "app/setDocument">, setEndpoints: import("@reduxjs/toolkit").ActionCreatorWithPayload<Endpoint[], "app/setEndpoints">, setScreen: import("@reduxjs/toolkit").ActionCreatorWithPayload<Screen, "app/setScreen">, setMode: import("@reduxjs/toolkit").ActionCreatorWithPayload<AppMode, "app/setMode">, setCommandInput: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "app/setCommandInput">, setError: import("@reduxjs/toolkit").ActionCreatorWithPayload<string | null, "app/setError">, setLoading: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "app/setLoading">, listSelect: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, "app/listSelect">, listSetFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<HttpMethod | "ALL", "app/listSetFilter">, listSetTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<string | null, "app/listSetTag">, listSetFocus: import("@reduxjs/toolkit").ActionCreatorWithPayload<"LIST" | "TAGS", "app/listSetFocus">, listSelectTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, "app/listSelectTag">, listSetSearch: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "app/listSetSearch">, listSetTagSearch: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "app/listSetTagSearch">, listScroll: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, "app/listScroll">, detailSet: import("@reduxjs/toolkit").ActionCreatorWithPayload<Endpoint, "app/detailSet">, detailSetFocus: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, "app/detailSetFocus">, detailSetParam: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    key: string;
+    value: string;
+}, "app/detailSetParam">, detailSetBody: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "app/detailSetBody">, detailSetHeader: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    key: string;
+    value: string;
+}, "app/detailSetHeader">, detailSetPanel: import("@reduxjs/toolkit").ActionCreatorWithPayload<"left" | "request" | "response", "app/detailSetPanel">, detailSetRequestTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<"headers" | "query" | "body", "app/detailSetRequestTab">, detailSetResponseTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<"headers" | "body" | "cookies" | "curl", "app/detailSetResponseTab">, detailSetResponse: import("@reduxjs/toolkit").ActionCreatorWithPayload<ApiResponse | null, "app/detailSetResponse">, reset: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"app/reset">;
+declare const _default: import("@reduxjs/toolkit").Reducer<AppState>;
+export default _default;