@gomjellie/lazyapi 0.0.1

package/dist/utils/schema-formatter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Schema를 읽기 쉬운 형태로 포맷팅하는 유틸리티
+ */
+import type { SchemaObject, OpenAPIDocument, ReferenceObject } from '../types/openapi.js';
+interface FormatOptions {
+    indent?: number;
+    maxDepth?: number;
+    currentDepth?: number;
+    document: OpenAPIDocument;
+}
+/**
+ * Schema를 TypeScript 인터페이스 스타일로 포맷팅
+ */
+export declare function formatSchema(schema: SchemaObject | ReferenceObject, options: FormatOptions): string[];
+/**
+ * Schema 전체를 포맷팅 (최상위 레벨)
+ */
+export declare function formatSchemaFull(schema: SchemaObject | {
+    $ref: string;
+}, document: OpenAPIDocument, maxDepth?: number): string[];
+export {};

package/dist/utils/schema-formatter.js

@@ -0,0 +1,301 @@
+/**
+ * Schema를 읽기 쉬운 형태로 포맷팅하는 유틸리티
+ */
+import { isReferenceObject as checkIsRef, resolveRef as resolve } from '../types/openapi.js';
+/**
+ * Schema를 TypeScript 인터페이스 스타일로 포맷팅
+ */
+export function formatSchema(schema, options) {
+    const { indent = 0, maxDepth = 3, currentDepth = 0, document } = options;
+    const lines = [];
+    const indentStr = '  '.repeat(indent);
+    // $ref인 경우
+    if (checkIsRef(schema)) {
+        const refName = schema.$ref.split('/').pop() || schema.$ref;
+        // 최대 깊이 도달 시 참조만 표시
+        if (currentDepth >= maxDepth) {
+            lines.push(`${indentStr}${refName} { ... }`);
+            return lines;
+        }
+        const resolved = resolve(schema.$ref, document);
+        if (resolved) {
+            lines.push(`${indentStr}${refName} {`);
+            const innerLines = formatSchemaObject(resolved, {
+                ...options,
+                indent: indent + 1,
+                currentDepth: currentDepth + 1,
+            });
+            lines.push(...innerLines);
+            lines.push(`${indentStr}}`);
+        }
+        else {
+            lines.push(`${indentStr}${refName} { ... }`);
+        }
+        return lines;
+    }
+    // 일반 schema
+    return formatSchemaObject(schema, options);
+}
+function formatSchemaObject(schema, options) {
+    const { indent = 0, document, currentDepth = 0, maxDepth = 3 } = options;
+    const lines = [];
+    const indentStr = '  '.repeat(indent);
+    // Object 타입
+    if (schema.type === 'object' || schema.properties) {
+        const required = schema.required || [];
+        for (const [propName, propSchema] of Object.entries(schema.properties || {})) {
+            const isRequired = required.includes(propName);
+            const propNameStr = isRequired ? `${propName}*` : propName;
+            if (checkIsRef(propSchema)) {
+                // $ref 속성
+                const refName = propSchema.$ref.split('/').pop() || propSchema.$ref;
+                const resolved = resolve(propSchema.$ref, document);
+                if (resolved && (resolved.type === 'object' || resolved.properties)) {
+                    // 중첩 객체 처리
+                    if (currentDepth + 1 >= maxDepth) {
+                        // maxDepth 도달 시 축약
+                        lines.push(`${indentStr}${propNameStr}: ${refName} { ... }`);
+                    }
+                    else {
+                        // maxDepth 미도달 시 펼치기
+                        lines.push(`${indentStr}${propNameStr}: ${refName} {`);
+                        const innerLines = formatSchemaObject(resolved, {
+                            ...options,
+                            indent: indent + 1,
+                            currentDepth: currentDepth + 1,
+                        });
+                        lines.push(...innerLines);
+                        lines.push(`${indentStr}}`);
+                    }
+                }
+                else if (resolved) {
+                    // 단순 타입은 확장
+                    const typeStr = formatType(resolved);
+                    lines.push(`${indentStr}${propNameStr}: ${refName}(${typeStr})`);
+                }
+                else {
+                    lines.push(`${indentStr}${propNameStr}: ${refName}`);
+                }
+            }
+            else if (propSchema.type === 'array' && propSchema.items && checkIsRef(propSchema.items)) {
+                // Array with $ref items - 펼쳐서 표시
+                const refName = propSchema.items.$ref.split('/').pop() || propSchema.items.$ref;
+                const resolved = resolve(propSchema.items.$ref, document);
+                if (resolved && (resolved.type === 'object' || resolved.properties)) {
+                    // 객체 배열 - 펼쳐서 표시
+                    if (currentDepth + 1 >= maxDepth) {
+                        lines.push(`${indentStr}${propNameStr}: ${refName} { ... } []`);
+                    }
+                    else {
+                        lines.push(`${indentStr}${propNameStr}: ${refName} {`);
+                        const innerLines = formatSchemaObject(resolved, {
+                            ...options,
+                            indent: indent + 1,
+                            currentDepth: currentDepth + 1,
+                        });
+                        lines.push(...innerLines);
+                        lines.push(`${indentStr}} []`);
+                    }
+                }
+                else {
+                    // 단순 타입 배열
+                    lines.push(`${indentStr}${propNameStr}: ${refName} []`);
+                }
+            }
+            else {
+                // 일반 속성
+                const typeStr = formatType(propSchema);
+                const exampleStr = propSchema.example
+                    ? ` (example: ${JSON.stringify(propSchema.example)})`
+                    : '';
+                const descStr = propSchema.description ? ` // ${propSchema.description}` : '';
+                lines.push(`${indentStr}${propNameStr}: ${typeStr}${exampleStr}${descStr}`);
+            }
+        }
+        return lines;
+    }
+    // Array 타입
+    if (schema.type === 'array' && schema.items) {
+        const itemsSchema = schema.items;
+        if (checkIsRef(itemsSchema)) {
+            const refName = itemsSchema.$ref.split('/').pop() || itemsSchema.$ref;
+            const resolved = resolve(itemsSchema.$ref, document);
+            if (resolved && (resolved.type === 'object' || resolved.properties)) {
+                // 객체 배열 - 펼쳐서 표시
+                if (currentDepth >= maxDepth) {
+                    lines.push(`${indentStr}${refName} { ... } []`);
+                }
+                else {
+                    lines.push(`${indentStr}${refName} {`);
+                    const innerLines = formatSchemaObject(resolved, {
+                        ...options,
+                        indent: indent + 1,
+                        currentDepth: currentDepth + 1,
+                    });
+                    lines.push(...innerLines);
+                    lines.push(`${indentStr}} []`);
+                }
+            }
+            else {
+                // 단순 타입 배열
+                lines.push(`${indentStr}${refName} []`);
+            }
+        }
+        else {
+            const itemType = formatType(itemsSchema);
+            lines.push(`${indentStr}Array<${itemType}>`);
+        }
+        return lines;
+    }
+    // 단순 타입
+    const typeStr = formatType(schema);
+    lines.push(`${indentStr}${typeStr}`);
+    return lines;
+}
+/**
+ * Schema 타입을 문자열로 포맷팅
+ */
+function formatType(schema) {
+    // Enum 타입
+    if (schema.enum && Array.isArray(schema.enum)) {
+        const enumValues = schema.enum.map((v) => `'${v}'`).join(' | ');
+        return `Enum(${enumValues})`;
+    }
+    // Array 타입
+    if (schema.type === 'array' && schema.items) {
+        if (checkIsRef(schema.items)) {
+            const refName = schema.items.$ref.split('/').pop() || schema.items.$ref;
+            return `Array<${refName}>`;
+        }
+        const itemType = formatType(schema.items);
+        return `Array<${itemType}>`;
+    }
+    // 기본 타입
+    const schemaType = schema.type;
+    let typeStr;
+    if (Array.isArray(schemaType)) {
+        typeStr = schemaType.join(' | ');
+    }
+    else {
+        typeStr = schemaType || 'any';
+    }
+    // Format 추가
+    if (schema.format) {
+        typeStr = `${typeStr}($${schema.format})`;
+    }
+    return typeStr;
+}
+/**
+ * 복합 타입(oneOf, anyOf, allOf) 포맷팅
+ */
+function formatComplexType(schema, options) {
+    const { document } = options;
+    const lines = [];
+    // oneOf / anyOf
+    const variants = schema.oneOf || schema.anyOf;
+    if (variants) {
+        const types = variants.map(variant => {
+            if (checkIsRef(variant)) {
+                return variant.$ref.split('/').pop() || 'unknown';
+            }
+            return formatType(variant);
+        });
+        lines.push(types.join(' | '));
+        return lines;
+    }
+    // allOf
+    if (schema.allOf) {
+        // allOf는 객체들의 합집합이므로, 각 스키마의 속성을 병합해서 표시하는 것이 좋음
+        lines.push('{');
+        for (const subSchema of schema.allOf) {
+            if (checkIsRef(subSchema)) {
+                const refName = subSchema.$ref.split('/').pop() || subSchema.$ref;
+                const resolved = resolve(subSchema.$ref, document);
+                if (resolved) {
+                    const innerLines = formatSchemaObject(resolved, { ...options, indent: 1 });
+                    lines.push(...innerLines);
+                }
+                else {
+                    lines.push(`  ...${refName}`);
+                }
+            }
+            else {
+                const innerLines = formatSchemaObject(subSchema, { ...options, indent: 1 });
+                lines.push(...innerLines);
+            }
+        }
+        lines.push('}');
+        return lines;
+    }
+    return [];
+}
+/**
+ * Schema 전체를 포맷팅 (최상위 레벨)
+ */
+export function formatSchemaFull(schema, document, maxDepth = 3) {
+    const lines = [];
+    // $ref인 경우 먼저 resolve
+    let actualSchema;
+    let typeName = '';
+    if (checkIsRef(schema)) {
+        typeName = schema.$ref.split('/').pop() || '';
+        const resolved = resolve(schema.$ref, document);
+        if (!resolved) {
+            return [`${typeName} { ... }`];
+        }
+        actualSchema = resolved;
+    }
+    else {
+        actualSchema = schema;
+    }
+    // Array 타입 먼저 체크
+    if (actualSchema.type === 'array' && actualSchema.items) {
+        const innerLines = formatSchemaObject(actualSchema, {
+            indent: 0,
+            maxDepth,
+            currentDepth: 0,
+            document,
+        });
+        lines.push(...innerLines);
+        return lines;
+    }
+    // Complex types (oneOf, anyOf, allOf)
+    if (actualSchema.oneOf || actualSchema.anyOf || actualSchema.allOf) {
+        const complexLines = formatComplexType(actualSchema, {
+            indent: 0,
+            maxDepth,
+            currentDepth: 0,
+            document,
+        });
+        lines.push(...complexLines);
+        return lines;
+    }
+    // Object 타입
+    if (actualSchema.type === 'object' || actualSchema.properties) {
+        if (typeName) {
+            lines.push(`${typeName} {`);
+        }
+        else {
+            lines.push('{');
+        }
+        const innerLines = formatSchema(actualSchema, {
+            indent: 1,
+            maxDepth,
+            currentDepth: 0,
+            document,
+        });
+        lines.push(...innerLines);
+        lines.push('}');
+    }
+    else {
+        // 단순 타입
+        const typeStr = formatType(actualSchema);
+        if (typeName) {
+            lines.push(`${typeName}: ${typeStr}`);
+        }
+        else {
+            lines.push(typeStr);
+        }
+    }
+    return lines;
+}

package/dist/utils/validators.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 검증 유틸리티
+ */
+import { NormalizedParameter } from '../types/openapi.js';
+/**
+ * 파라미터 값 검증
+ */
+export declare function validateParameter(parameter: NormalizedParameter, value: string): string | null;
+/**
+ * JSON 문자열 검증
+ */
+export declare function validateJSON(json: string): string | null;
+/**
+ * URL 검증
+ */
+export declare function validateURL(url: string): string | null;

package/dist/utils/validators.js

@@ -0,0 +1,158 @@
+/**
+ * 검증 유틸리티
+ */
+/**
+ * 파라미터 값 검증
+ */
+export function validateParameter(parameter, value) {
+    // 필수 파라미터 검증
+    if (parameter.required && !value.trim()) {
+        return `${parameter.name}은(는) 필수 항목입니다`;
+    }
+    // 값이 없으면 추가 검증 스킵
+    if (!value.trim()) {
+        return null;
+    }
+    // 스키마 기반 검증
+    if (parameter.schema && typeof parameter.schema === 'object' && !('$ref' in parameter.schema)) {
+        const schema = parameter.schema;
+        // 타입 검증
+        if (schema.type) {
+            const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+            let hasValidType = false;
+            for (const type of types) {
+                if (type === 'null' && !value.trim()) {
+                    hasValidType = true;
+                    break;
+                }
+                const error = validateType(type, value);
+                if (!error) {
+                    hasValidType = true;
+                    break;
+                }
+            }
+            if (!hasValidType && types.length === 1) {
+                const error = validateType(types[0], value);
+                if (error) {
+                    return `${parameter.name}: ${error}`;
+                }
+            }
+        }
+        // enum 검증
+        if (schema.enum && Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+            return `${parameter.name}은(는) 다음 값 중 하나여야 합니다: ${schema.enum.map(String).join(', ')}`;
+        }
+        // 포맷 검증
+        if (schema.format) {
+            const error = validateFormat(schema.format, value);
+            if (error) {
+                return `${parameter.name}: ${error}`;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * 타입 검증
+ */
+function validateType(type, value) {
+    switch (type) {
+        case 'integer':
+        case 'number':
+            if (isNaN(Number(value))) {
+                return '숫자여야 합니다';
+            }
+            break;
+        case 'boolean':
+            if (value !== 'true' && value !== 'false') {
+                return 'true 또는 false여야 합니다';
+            }
+            break;
+        case 'array':
+            // 간단한 배열 검증 (쉼표로 구분)
+            // 실제로는 더 복잡한 검증이 필요할 수 있음
+            break;
+        case 'object':
+            try {
+                JSON.parse(value);
+            }
+            catch {
+                return '유효한 JSON 객체여야 합니다';
+            }
+            break;
+    }
+    return null;
+}
+/**
+ * 포맷 검증
+ */
+function validateFormat(format, value) {
+    switch (format) {
+        case 'email':
+            if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+                return '유효한 이메일 주소여야 합니다';
+            }
+            break;
+        case 'uri':
+        case 'url':
+            try {
+                new URL(value);
+            }
+            catch {
+                return '유효한 URL이어야 합니다';
+            }
+            break;
+        case 'uuid':
+            if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
+                return '유효한 UUID여야 합니다';
+            }
+            break;
+        case 'date':
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+                return '유효한 날짜 형식(YYYY-MM-DD)이어야 합니다';
+            }
+            break;
+        case 'date-time':
+            try {
+                new Date(value).toISOString();
+            }
+            catch {
+                return '유효한 날짜-시간 형식이어야 합니다';
+            }
+            break;
+    }
+    return null;
+}
+/**
+ * JSON 문자열 검증
+ */
+export function validateJSON(json) {
+    if (!json.trim()) {
+        return null;
+    }
+    try {
+        JSON.parse(json);
+        return null;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return `유효하지 않은 JSON: ${error.message}`;
+        }
+        return '유효하지 않은 JSON';
+    }
+}
+/**
+ * URL 검증
+ */
+export function validateURL(url) {
+    if (!url.trim()) {
+        return 'URL을 입력해주세요';
+    }
+    try {
+        new URL(url);
+        return null;
+    }
+    catch {
+        return '유효한 URL을 입력해주세요';
+    }
+}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@gomjellie/lazyapi",
+  "version": "0.0.1",
+  "description": "A terminal-based Swagger/OpenAPI explorer with Vim-style keyboard navigation",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "lazyapi": "./dist/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.tsx",
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "typecheck": "tsc --noEmit",
+    "prepush": "pnpm lint && pnpm typecheck && pnpm test",
+    "prepare": "node scripts/install-hooks.mjs || true",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "swagger",
+    "openapi",
+    "cli",
+    "tui",
+    "terminal",
+    "vim",
+    "api",
+    "rest"
+  ],
+  "author": "gomjellie",
+  "license": "MIT",
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^10.1.0",
+    "@reduxjs/toolkit": "^2.11.2",
+    "axios": "^1.6.2",
+    "clipboardy": "^4.0.0",
+    "ink": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^19.2.3",
+    "react-redux": "^9.2.0",
+    "yaml": "^2.3.4"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.1",
+    "@total-typescript/ts-reset": "^0.6.1",
+    "@types/node": "^22.12.0",
+    "@types/react": "^19.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.23.0",
+    "@typescript-eslint/parser": "^8.23.0",
+    "@vitest/coverage-v8": "^4.0.16",
+    "@vitest/ui": "^4.0.16",
+    "eslint": "^9.23.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "husky": "^9.1.7",
+    "ink-testing-library": "^4.0.0",
+    "jsdom": "^27.3.0",
+    "openapi-types": "^12.1.3",
+    "prettier": "^3.7.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gomjellie/lazyapi.git"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}