Naite Viewer

import { createHash } from "crypto";

const configPath = "/project/api/src/sonamu.config.ts";
const hash = createHash("md5")
  .update(configPath)
  .digest("hex")
  .slice(0, 8);

// 예: "a1b2c3d4"
// 최종 소켓 경로: ~/.sonamu/naite-a1b2c3d4.sock

// 1. 테스트 시작 - 소켓 연결 및 run/start 전송
beforeAll(async () => {
  await NaiteReporter.startTestRun();
  // → send({ type: "run/start" })
});

// 2. 테스트 실행 - Naite 로그 수집
test("사용자 생성", async () => {
  Naite.t("user:create:input", { username: "john" });
  
  const { user } = await userModel.create({ username: "john" });
  
  Naite.t("user:create:output", { userId: user.id });
  
  // 테스트 종료 후 afterEach 실행
});

// 3. 테스트 종료 - traces 수집 및 전송
afterEach(async ({ task }) => {
  // getAllTraces()로 모든 Naite 로그 수집
  task.meta.traces = Naite.getAllTraces();
  
  // Extension으로 전송
  await NaiteReporter.reportTestResult({
    testName: task.name,
    status: task.result?.state,
    traces: task.meta.traces,
    // ...
  });
  // → send({ type: "test/result", traces: [...] })
});

// 4. 전체 런 종료 - run/end 전송 및 소켓 종료
afterAll(() => {
  await NaiteReporter.endTestRun();
  // → send({ type: "run/end" })
  // → socket.end()
});

user:create:input
{ username: "john", email: "john@example.com" }

📍 직접 호출 위치:
  /Users/.../user.model.test.ts:20
  
📚 전체 콜스택:
  1. test (user.model.test.ts:20)
     ↑ 클릭하면 이 위치로 이동
  2. createUser (user.model.ts:45)
  3. runWithMockContext (bootstrap.ts:58)

✓ 주문 처리 전체 흐름 (456ms)
  └─ order:validate:start     { orderId: 123 }
  └─ order:validate:done      { valid: true }
  └─ order:inventory:check    { productId: 456 }
  └─ order:inventory:available { quantity: 10 }
  └─ order:payment:start      { amount: 50000 }
  └─ order:payment:done       { transactionId: "tx_789" }
  └─ order:shipping:start     { orderId: 123 }
  └─ order:shipping:done      { trackingNumber: "TRK_001" }

✓ User 엔티티 전체 생성 (2.3s)
  └─ syncer:generateAll:start     { entityId: "User" }
  └─ syncer:renderTemplate        { template: "model", entityId: "User" }
  └─ syncer:writeFile             { path: "user.model.ts" }
  └─ syncer:renderTemplate        { template: "types", entityId: "User" }
  └─ syncer:writeFile             { path: "user.types.ts" }
  └─ syncer:renderTemplate        { template: "service", entityId: "User" }
  └─ syncer:writeFile             { path: "user.service.ts" }
  └─ syncer:generateAll:done      { filesCreated: 3 }

✓ 대용량 데이터 처리 성능 (5.2s)
  perf:start          12:34:56.000
  perf:fetch:start    12:34:56.001
  perf:fetch:done     12:34:57.500  ← 1.5초 소요
  perf:process:start  12:34:57.501
  perf:process:done   12:35:00.800  ← 3.3초 소요 (병목!)
  perf:save:start     12:35:00.801
  perf:save:done      12:35:01.200  ← 0.4초 소요
  perf:end            12:35:01.201

class NaiteReporterClass {
  private socketPath: string | null = null;
  private socket: Socket | null = null;
  private connected = false;
  private buffer: string[] = [];

  /**
   * 소켓 연결 확보
   * - 이미 연결되어 있으면 즉시 반환
   * - 연결 중이면 버퍼에 메시지 저장
   * - 연결 실패는 무시 (Extension이 꺼져있을 수 있음)
   */
  private async ensureConnection(): Promise<void> {
    if (this.connected) return;
    
    return new Promise((resolve, reject) => {
      this.socketPath = getSocketPath();
      this.socket = connect(this.socketPath);
      
      this.socket.on("connect", () => {
        this.connected = true;
        
        // 버퍼에 쌓인 메시지 전송
        for (const msg of this.buffer) {
          this.socket?.write(msg);
        }
        this.buffer = [];
        
        resolve();
      });
      
      this.socket.on("error", () => {
        // Extension이 꺼져있을 수 있으므로 에러 무시
        this.connected = false;
        this.socket = null;
        reject();
      });
      
      this.socket.on("close", () => {
        this.connected = false;
        this.socket = null;
      });
    });
  }

  /**
   * 메시지 전송
   * - 연결되어 있으면 즉시 전송
   * - 연결 중이면 버퍼에 저장
   */
  private async send(data: NaiteMessage): Promise<void> {
    const msg = `${JSON.stringify(data)}\n`;
    
    await this.ensureConnection().catch(() => {});
    
    if (this.connected && this.socket) {
      this.socket.write(msg);
    } else {
      this.buffer.push(msg);
    }
  }

  async startTestRun() {
    if (process.env.CI) return; // CI에서는 무시
    
    await this.send({
      type: "run/start",
      startedAt: new Date().toISOString(),
    });
  }

  async reportTestResult(result: TestResult) {
    if (process.env.CI) return;
    
    await this.send({
      type: "test/result",
      receivedAt: new Date().toISOString(),
      ...result,
    });
  }

  async endTestRun() {
    if (process.env.CI) return;
    
    await this.send({
      type: "run/end",
      endedAt: new Date().toISOString(),
    });
    
    // 소켓 종료
    if (this.socket) {
      this.socket.end();
      this.socket = null;
      this.connected = false;
    }
  }
}

export const test = Object.assign(
  async (title: string, fn: TestFunction<object>, options?: TestOptions) => {
    return vitestTest(title, options, async (context) => {
      await runWithMockContext(async () => {
        try {
          // 테스트 실행
          await fn(context);
          
          // 성공 시에도 traces 수집
          context.task.meta.traces = Naite.getAllTraces();
        } catch (e: unknown) {
          // 실패 시에도 traces 수집 (에러 추적용)
          context.task.meta.traces = Naite.getAllTraces();
          throw e;
        }
      });
    });
  },
  // ... skip, only, todo 등도 동일하게 처리
);

// afterEach에서 Extension으로 전송
afterEach(async ({ task }) => {
  await NaiteReporter.reportTestResult({
    suiteName: task.suite?.name ?? "(no suite)",
    suiteFilePath: task.file?.filepath,
    testName: task.name,
    testFilePath: task.file?.filepath ?? "",
    testLine: task.location?.line ?? 0,
    status: task.result?.state ?? "pass",
    duration: task.result?.duration ?? 0,
    error: task.result?.errors?.[0]
      ? {
          message: task.result.errors[0].message,
          stack: task.result.errors[0].stack,
        }
      : undefined,
    traces: task.meta?.traces ?? [],
  });
});