fix: 빈 타입 생성 누락 문제 수정

- parsed.docs가 있지만 JSON 추출 실패 시에도 void 타입 생성
- 빈 객체 {}인 경우 Record<string, never> 타입 생성
- typeGenerator에서 빈 인터페이스를 Record<string, never>로 변환
- 빈 타입 생성 케이스에 대한 테스트 추가

Author: manNomi

src/generator/apiFactoryGenerator.ts

@@ -7,6 +7,18 @@ import { ParsedBrunoFile, extractJsonFromDocs } from '../parser/bruParser';
 import { ApiFunction } from './apiClientGenerator';
 import { generateTypeScriptInterface, toCamelCase, functionNameToTypeName } from './typeGenerator';
 
+/**
+ * 빈 인터페이스를 Record<string, never> 타입으로 변환
+ */
+function convertEmptyInterfaceToType(content: string, typeName: string): string {
+  // 빈 인터페이스 패턴: export interface TypeName { }
+  const emptyInterfacePattern = new RegExp(`export interface ${typeName}\\s*\\{\\s*\\}`);
+  if (emptyInterfacePattern.test(content)) {
+    return `export type ${typeName} = Record<string, never>;`;
+  }
+  return content;
+}
+
 /**
  * 팩토리용 API 함수 코드 생성 (객체 속성으로 사용)
  */
@@ -91,14 +103,35 @@ export function generateApiFactory(
     // Response 타입 생성
     if (parsed.docs) {
       const jsonData = extractJsonFromDocs(parsed.docs);
-      if (jsonData) {
-        const typeDefs = generateTypeScriptInterface(jsonData, responseType);
-        for (const typeDef of typeDefs) {
-          if (!typeDefinitions.has(typeDef.content)) {
-            typeDefinitions.add(typeDef.content);
-            lines.push(typeDef.content);
+      if (jsonData !== null && jsonData !== undefined) {
+        // 빈 객체 체크
+        if (typeof jsonData === 'object' && !Array.isArray(jsonData) && Object.keys(jsonData).length === 0) {
+          // 빈 객체인 경우 Record<string, never> 타입 생성
+          const emptyType = `export type ${responseType} = Record<string, never>;`;
+          if (!typeDefinitions.has(emptyType)) {
+            typeDefinitions.add(emptyType);
+            lines.push(emptyType);
             lines.push('');
           }
+        } else {
+          const typeDefs = generateTypeScriptInterface(jsonData, responseType);
+          for (const typeDef of typeDefs) {
+            // 빈 인터페이스 체크 및 변환
+            const processedContent = convertEmptyInterfaceToType(typeDef.content, responseType);
+            if (!typeDefinitions.has(processedContent)) {
+              typeDefinitions.add(processedContent);
+              lines.push(processedContent);
+              lines.push('');
+            }
+          }
+        }
+      } else {
+        // JSON 추출 실패 시 void 타입 생성
+        const defaultType = `export type ${responseType} = void;`;
+        if (!typeDefinitions.has(defaultType)) {
+          typeDefinitions.add(defaultType);
+          lines.push(defaultType);
+          lines.push('');
         }
       }
     } else {

src/generator/typeGenerator.ts

@@ -99,8 +99,14 @@ export function generateTypeScriptInterface(
     properties.push(`  ${key}: ${type};`);
   }
 
-  const mainInterface = `export interface ${interfaceName} {\n${properties.join('\n')}\n}`;
-  definitions.push({ name: interfaceName, content: mainInterface });
+  // 빈 인터페이스인 경우 Record<string, never> 타입으로 생성
+  if (properties.length === 0) {
+    const emptyType = `export type ${interfaceName} = Record<string, never>;`;
+    definitions.push({ name: interfaceName, content: emptyType });
+  } else {
+    const mainInterface = `export interface ${interfaceName} {\n${properties.join('\n')}\n}`;
+    definitions.push({ name: interfaceName, content: mainInterface });
+  }
 
   return definitions;
 }

tests/cli.test.js

@@ -453,5 +453,159 @@ docs {
   });
 });
 
+describe('빈 타입 생성 테스트', () => {
+  test('빈 객체 {}인 경우 Record<string, never> 타입 생성', () => {
+    const emptyObjectFixtureDir = join(FIXTURES_DIR, 'bruno-empty-object');
+    mkdirSync(emptyObjectFixtureDir, { recursive: true });
+    
+    // 폴더 구조 생성
+    const testFolder = join(emptyObjectFixtureDir, 'test');
+    mkdirSync(testFolder, { recursive: true });
+
+    const emptyObjectFile = join(testFolder, 'empty-response.bru');
+    const emptyObjectContent = `meta {
+  name: Empty Response Test
+  type: http
+}
+
+get /test/empty
+
+docs {
+  \`\`\`json
+  {}
+  \`\`\`
+}
+`;
+    require('fs').writeFileSync(emptyObjectFile, emptyObjectContent);
+
+    const outputDir = join(TEST_OUTPUT_DIR, 'empty-object-output');
+    execSync(`node dist/cli/index.js generate-hooks -i ${emptyObjectFixtureDir} -o ${outputDir}`, {
+      cwd: join(__dirname, '..'),
+    });
+
+    // api.ts 파일 확인 (도메인은 폴더명 'test'가 됨)
+    const apiFile = join(outputDir, 'test', 'api.ts');
+    assert.ok(existsSync(apiFile), 'api.ts 파일이 생성되어야 함');
+
+    const apiContent = readFileSync(apiFile, 'utf-8');
+    assert.ok(apiContent.includes('Record<string, never>'), '빈 객체는 Record<string, never> 타입이어야 함');
+    assert.ok(!apiContent.includes('export interface'), '빈 인터페이스는 생성되지 않아야 함');
+
+    console.log('✅ 빈 객체 Record<string, never> 타입 생성 테스트 통과');
+  });
+
+  test('parsed.docs가 있지만 JSON 추출 실패 시 void 타입 생성', () => {
+    const invalidJsonFixtureDir = join(FIXTURES_DIR, 'bruno-invalid-json');
+    mkdirSync(invalidJsonFixtureDir, { recursive: true });
+    
+    // 폴더 구조 생성
+    const testFolder = join(invalidJsonFixtureDir, 'test');
+    mkdirSync(testFolder, { recursive: true });
+
+    const invalidJsonFile = join(testFolder, 'invalid-json.bru');
+    const invalidJsonContent = `meta {
+  name: Invalid JSON Test
+  type: http
+}
+
+get /test/invalid
+
+docs {
+  이것은 유효하지 않은 JSON입니다
+  { invalid json }
+}
+`;
+    require('fs').writeFileSync(invalidJsonFile, invalidJsonContent);
+
+    const outputDir = join(TEST_OUTPUT_DIR, 'invalid-json-output');
+    execSync(`node dist/cli/index.js generate-hooks -i ${invalidJsonFixtureDir} -o ${outputDir}`, {
+      cwd: join(__dirname, '..'),
+    });
+
+    // api.ts 파일 확인 (도메인은 폴더명 'test'가 됨)
+    const apiFile = join(outputDir, 'test', 'api.ts');
+    assert.ok(existsSync(apiFile), 'api.ts 파일이 생성되어야 함');
+
+    const apiContent = readFileSync(apiFile, 'utf-8');
+    assert.ok(apiContent.includes('void'), 'JSON 추출 실패 시 void 타입이 생성되어야 함');
+
+    console.log('✅ JSON 추출 실패 시 void 타입 생성 테스트 통과');
+  });
+
+  test('빈 배열 []인 경우 any[] 타입 생성', () => {
+    const emptyArrayFixtureDir = join(FIXTURES_DIR, 'bruno-empty-array');
+    mkdirSync(emptyArrayFixtureDir, { recursive: true });
+    
+    // 폴더 구조 생성
+    const testFolder = join(emptyArrayFixtureDir, 'test');
+    mkdirSync(testFolder, { recursive: true });
+
+    const emptyArrayFile = join(testFolder, 'empty-array.bru');
+    const emptyArrayContent = `meta {
+  name: Empty Array Test
+  type: http
+}
+
+get /test/empty-array
+
+docs {
+  \`\`\`json
+  {
+    "items": []
+  }
+  \`\`\`
+}
+`;
+    require('fs').writeFileSync(emptyArrayFile, emptyArrayContent);
+
+    const outputDir = join(TEST_OUTPUT_DIR, 'empty-array-output');
+    execSync(`node dist/cli/index.js generate-hooks -i ${emptyArrayFixtureDir} -o ${outputDir}`, {
+      cwd: join(__dirname, '..'),
+    });
+
+    // api.ts 파일 확인 (도메인은 폴더명 'test'가 됨)
+    const apiFile = join(outputDir, 'test', 'api.ts');
+    assert.ok(existsSync(apiFile), 'api.ts 파일이 생성되어야 함');
+
+    const apiContent = readFileSync(apiFile, 'utf-8');
+    assert.ok(apiContent.includes('any[]'), '빈 배열은 any[] 타입이어야 함');
+
+    console.log('✅ 빈 배열 any[] 타입 생성 테스트 통과');
+  });
+
+  test('parsed.docs가 없는 경우 void 타입 생성', () => {
+    const noDocsFixtureDir = join(FIXTURES_DIR, 'bruno-no-docs');
+    mkdirSync(noDocsFixtureDir, { recursive: true });
+    
+    // 폴더 구조 생성
+    const testFolder = join(noDocsFixtureDir, 'test');
+    mkdirSync(testFolder, { recursive: true });
+
+    const noDocsFile = join(testFolder, 'no-docs.bru');
+    const noDocsContent = `meta {
+  name: No Docs Test
+  type: http
+}
+
+get /test/no-docs
+`;
+    require('fs').writeFileSync(noDocsFile, noDocsContent);
+
+    const outputDir = join(TEST_OUTPUT_DIR, 'no-docs-output');
+    execSync(`node dist/cli/index.js generate-hooks -i ${noDocsFixtureDir} -o ${outputDir}`, {
+      cwd: join(__dirname, '..'),
+    });
+
+    // api.ts 파일 확인 (도메인은 폴더명 'test'가 됨)
+    const apiFile = join(outputDir, 'test', 'api.ts');
+    assert.ok(existsSync(apiFile), 'api.ts 파일이 생성되어야 함');
+
+    const apiContent = readFileSync(apiFile, 'utf-8');
+    assert.ok(apiContent.includes('void'), 'docs가 없으면 void 타입이 생성되어야 함');
+
+    console.log('✅ docs 없을 때 void 타입 생성 테스트 통과');
+  });
+});
+
 console.log('\n🎉 모든 테스트 완료!');
 

tests/fixtures/bruno-empty-array/empty-array.bru

@@ -0,0 +1,14 @@
+meta {
+  name: Empty Array Test
+  type: http
+}
+
+get /test/empty-array
+
+docs {
+  ```json
+  {
+    "items": []
+  }
+  ```
+}

tests/fixtures/bruno-empty-array/test/empty-array.bru

@@ -0,0 +1,14 @@
+meta {
+  name: Empty Array Test
+  type: http
+}
+
+get /test/empty-array
+
+docs {
+  ```json
+  {
+    "items": []
+  }
+  ```
+}

tests/fixtures/bruno-empty-object/empty-response.bru

@@ -0,0 +1,12 @@
+meta {
+  name: Empty Response Test
+  type: http
+}
+
+get /test/empty
+
+docs {
+  ```json
+  {}
+  ```
+}

tests/fixtures/bruno-empty-object/test/empty-response.bru

@@ -0,0 +1,12 @@
+meta {
+  name: Empty Response Test
+  type: http
+}
+
+get /test/empty
+
+docs {
+  ```json
+  {}
+  ```
+}

tests/fixtures/bruno-invalid-json/invalid-json.bru

@@ -0,0 +1,11 @@
+meta {
+  name: Invalid JSON Test
+  type: http
+}
+
+get /test/invalid
+
+docs {
+  이것은 유효하지 않은 JSON입니다
+  { invalid json }
+}

tests/fixtures/bruno-invalid-json/test/invalid-json.bru

@@ -0,0 +1,11 @@
+meta {
+  name: Invalid JSON Test
+  type: http
+}
+
+get /test/invalid
+
+docs {
+  이것은 유효하지 않은 JSON입니다
+  { invalid json }
+}

tests/fixtures/bruno-no-docs/no-docs.bru

@@ -0,0 +1,6 @@
+meta {
+  name: No Docs Test
+  type: http
+}
+
+get /test/no-docs