sonamu 0.6.0 → 0.7.0

package/src/naite/naite-reporter.ts

@@ -0,0 +1,128 @@
+/**
+ * NaiteReporter
+ *
+ * 테스트 결과와 Trace 정보를 Unix Socket으로 VS Code extension에 전달합니다.
+ * extension이 ~/.sonamu/naite.sock에 소켓 서버를 열어둡니다.
+ *
+ * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.
+ */
+/** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */
+
+import { connect, type Socket } from "net";
+import { homedir } from "os";
+import { join } from "path";
+import type { NaiteMessagingTypes } from "./messaging-types";
+
+// 소켓 경로
+const SOCKET_PATH =
+  process.platform === "win32" ? "\\\\.\\pipe\\naite" : join(homedir(), ".sonamu", "naite.sock");
+
+class NaiteReporterClass {
+  private socket: Socket | null = null;
+  private connected = false;
+  private buffer: string[] = [];
+
+  /**
+   * 소켓 연결 시도
+   */
+  private ensureConnection(): void {
+    if (this.connected || this.socket) return;
+
+    try {
+      this.socket = connect(SOCKET_PATH);
+
+      this.socket.on("connect", () => {
+        this.connected = true;
+        // 버퍼에 쌓인 메시지 전송
+        for (const msg of this.buffer) {
+          this.socket?.write(msg);
+        }
+        this.buffer = [];
+      });
+
+      this.socket.on("error", () => {
+        // 연결 실패 무시 (extension이 꺼져있을 수 있음)
+        this.connected = false;
+        this.socket = null;
+      });
+
+      this.socket.on("close", () => {
+        this.connected = false;
+        this.socket = null;
+      });
+    } catch {
+      // 연결 실패 무시
+    }
+  }
+
+  /**
+   * 메시지 전송 (줄바꿈으로 구분)
+   */
+  private send(data: NaiteMessagingTypes.NaiteMessage): void {
+    const msg = `${JSON.stringify(data)}\n`;
+
+    this.ensureConnection();
+
+    if (this.connected && this.socket) {
+      this.socket.write(msg);
+    } else {
+      // 연결 대기 중이면 버퍼에 저장
+      this.buffer.push(msg);
+    }
+  }
+
+  /**
+   * beforeAll에서 호출합니다.
+   * 테스트 run 시작을 알립니다 (데이터 클리어 신호).
+   */
+  startTestRun(): void {
+    if (process.env.CI) {
+      return;
+    }
+
+    this.send({
+      type: "run/start",
+      startedAt: new Date().toISOString(),
+    });
+  }
+
+  /**
+   * afterEach에서 호출합니다.
+   * 테스트 케이스 결과를 traces와 함께 전송합니다.
+   */
+  reportTestResult(result: Omit<NaiteMessagingTypes.TestResult, "receivedAt">): void {
+    if (process.env.CI) {
+      return;
+    }
+
+    this.send({
+      type: "test/result",
+      receivedAt: new Date().toISOString(),
+      ...result,
+    });
+  }
+
+  /**
+   * afterAll에서 호출합니다.
+   * 테스트 run 종료를 알립니다.
+   */
+  endTestRun(): void {
+    if (process.env.CI) {
+      return;
+    }
+
+    this.send({
+      type: "run/end",
+      endedAt: new Date().toISOString(),
+    });
+
+    // 연결 종료
+    if (this.socket) {
+      this.socket.end();
+      this.socket = null;
+      this.connected = false;
+    }
+  }
+}
+
+export const NaiteReporter = new NaiteReporterClass();

package/src/naite/naite.ts

@@ -1,70 +1,415 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */
+
+import { get } from "radashi";
 import { Sonamu } from "../api/sonamu";
+import type { ComparisonOperator } from "../database/puri.types";
+import { isSerializable } from "../utils/object-utils";
+
+// StackFrame 타입
+interface StackFrame {
+  functionName: string | null;
+  filePath: string; // "/Users/.../syncer.ts" 또는 "node:internal/..."
+  lineNumber: number; // TS 파일 기준 라인 번호
+}
+
+// NaiteTrace 타입
+interface NaiteTrace {
+  key: string;
+  data: any;
+  stack: StackFrame[]; // 콜스택 정보
+  at: Date;
+}
+
+// Naite.t가 저장되는 타입 (항상 배열로 통일)
+export type NaiteStore = Map<string, NaiteTrace[]>;
+
+/**
+ * 콜스택을 파싱하여 StackFrame 배열로 반환
+ * - extractCallStack 자신과 Naite.t는 제외
+ * - runWithContext/runWithMockContext 발견 시 거기서 종료
+ * - node: 내부 경로는 포함하되, lineNumber는 path에 : 포함 시 붙이지 않음
+ */
+function extractCallStack(): StackFrame[] {
+  const stack = new Error().stack;
+  if (!stack) return [];
+
+  const lines = stack.split("\n");
+
+  // 콜스택 구조:
+  // [0]: "Error"
+  // [1]: "at extractCallStack"
+  // [2]: "at Naite.t"
+  // [3]: 실제 호출 위치부터 시작
+  const frames = lines
+    .slice(3)
+    .map(parseStackFrame)
+    .filter((frame): frame is StackFrame => frame !== null);
+
+  // runWithContext 계열 함수 발견 시 거기서 자르기
+  const contextIndex = frames.findIndex(
+    (f) =>
+      f.functionName?.includes("runWithContext") || f.functionName?.includes("runWithMockContext"),
+  );
+
+  return contextIndex >= 0 ? frames.slice(0, contextIndex + 1) : frames;
+}
+
+/**
+ * 콜스택 한 줄을 파싱
+ * 형식1: "at FunctionName (filePath:lineNumber:columnNumber)"
+ * 형식2: "at filePath:lineNumber:columnNumber" (익명 함수/모듈 레벨)
+ */
+function parseStackFrame(line: string): StackFrame | null {
+  // 패턴1: "at FunctionName (filePath:lineNumber:columnNumber)"
+  const matchWithFunc = line.match(/at\s+(.+?)\s+\((.+?):(\d+):\d+\)/);
+  if (matchWithFunc) {
+    const functionName = matchWithFunc[1];
+    const filePath = matchWithFunc[2];
+    const lineNumberStr = matchWithFunc[3];
+
+    // filePath에 이미 :가 포함되어 있으면 (예: "node:internal/...")
+    if (filePath.includes(":")) {
+      return { functionName, filePath, lineNumber: 0 };
+    }
+
+    return {
+      functionName,
+      filePath,
+      lineNumber: Number.parseInt(lineNumberStr, 10),
+    };
+  }
+
+  // 패턴2: "at filePath:lineNumber:columnNumber" (함수명 없음)
+  const matchNoFunc = line.match(/at\s+(.+?):(\d+):\d+$/);
+  if (matchNoFunc) {
+    const filePath = matchNoFunc[1];
+    const lineNumberStr = matchNoFunc[2];
+
+    return {
+      functionName: null,
+      filePath,
+      lineNumber: Number.parseInt(lineNumberStr, 10),
+    };
+  }
+
+  return null;
+}
+
+/**
+ * wildcard 패턴 매칭
+ * 예시:
+ * - "syncer:*" → "syncer:a", "syncer:a:b" 모두 매칭
+ * - "syncer:*:user" → "syncer:renderTemplate:user" 매칭
+ * - "syncer:renderTemplate:*" → "syncer:renderTemplate:service" 매칭
+ */
+function matchesPattern(key: string, pattern: string): boolean {
+  const keyParts = key.split(":");
+  const patternParts = pattern.split(":");
+
+  // 마지막이 * → prefix 매칭 (길이 무관)
+  // 예: "syncer:*"는 "syncer:a", "syncer:a:b" 모두 매칭
+  if (patternParts[patternParts.length - 1] === "*") {
+    const prefixParts = patternParts.slice(0, -1);
+    // prefix가 모두 일치하는지 확인
+    return prefixParts.every((part, i) => part === keyParts[i]);
+  }
+
+  // 길이가 같아야 함
+  if (patternParts.length !== keyParts.length) {
+    return false;
+  }
+
+  // 각 파트가 * 또는 정확히 일치
+  return patternParts.every((part, i) => part === "*" || part === keyParts[i]);
+}
+
+/**
+ * NaiteQuery 클래스
+ * 체이닝을 통한 trace 필터링 및 조회
+ */
+export class NaiteQuery {
+  constructor(private traces: NaiteTrace[]) {}
+
+  /**
+   * 파일명으로 필터링
+   * @param fileName 파일명 (예: "syncer.test.ts")
+   */
+  fromFile(fileName: string): NaiteQuery {
+    const filtered = this.traces.filter((t) =>
+      t.stack.some((frame) => frame.filePath.endsWith(`/${fileName}`)),
+    );
+    return new NaiteQuery(filtered);
+  }
+
+  /**
+   * 함수명으로 필터링
+   * @param funcName 함수명 (includes 체크)
+   * @param options.from 'direct' = 직접 호출만, 'indirect' = 간접 호출만, 'both' = 모두
+   */
+  fromFunction(
+    funcName: string,
+    options: { from: "direct" | "indirect" | "both" } = { from: "both" },
+  ): NaiteQuery {
+    const filtered = this.traces.filter((t) => {
+      if (options.from === "direct") {
+        // stack[0]만 확인 (직접 호출)
+        return t.stack[0]?.functionName?.includes(funcName);
+      }
+      if (options.from === "indirect") {
+        // stack[1+]에서 확인 (간접 호출)
+        return t.stack.slice(1).some((f) => f.functionName?.includes(funcName));
+      }
+      // 전체 스택에서 확인
+      return t.stack.some((f) => f.functionName?.includes(funcName));
+    });
+    return new NaiteQuery(filtered);
+  }
+
+  /**
+   * 데이터 경로 기반 필터링
+   * @param path radash get 경로 (예: "data.userId")
+   * @param operator 비교 연산자
+   * @param value 비교값
+   */
+  where(path: string, operator: ComparisonOperator | "includes", value: any): NaiteQuery {
+    const filtered = this.traces.filter((trace) => {
+      const actual = get(trace, path) as any;
+
+      switch (operator) {
+        case ">":
+          return actual > value;
+        case "<":
+          return actual < value;
+        case ">=":
+          return actual >= value;
+        case "<=":
+          return actual <= value;
+        case "=":
+          return actual === value;
+        case "!=":
+          return actual !== value;
+        case "includes":
+          return typeof actual === "string" && actual.includes(value);
+        default:
+          return false;
+      }
+    });
+    return new NaiteQuery(filtered);
+  }
+
+  /**
+   * 전체 데이터 배열 반환
+   */
+  result(): any[] {
+    return this.traces.map((t) => t.data);
+  }
+
+  /**
+   * 첫 번째 데이터 반환
+   */
+  first(): any | undefined {
+    return this.traces[0]?.data;
+  }
 
-export class Naite {
+  /**
+   * 마지막 데이터 반환
+   */
+  last(): any | undefined {
+    return this.traces[this.traces.length - 1]?.data;
+  }
+
+  /**
+   * n번째 데이터 반환
+   */
+  at(index: number): any | undefined {
+    return this.traces[index]?.data;
+  }
+
+  /**
+   * 원본 trace 배열 반환 (디버깅/NaiteViewer용)
+   */
+  getTraces(): NaiteTrace[] {
+    return this.traces;
+  }
+}
+
+// Naite 싱글턴 객체 (추후 logger 연결 등의 상태 관리 필요성 고려)
+export class NaiteClass {
   // 테스트 로그 기록
-  static t(name: string, value: any) {
+  t(
+    name: string,
+    value: any /*이렇게 받은 값이 NaiteTrace로 저장되어 있다가 추후에 vitest에게 meta를 통해 넘겨져 프로세스간 통신을 통해 직렬화되어야 하는 점을 고려하였을 때 여기에 Serializable을 써서 제한을 둘 수도 있지만, 사용상의 편의를 생각하여 any로 받습니다.*/,
+  ) {
+    // 이 t 함수는 테스트 환경에서만 작동해야 합니다.
+    // 그리고 테스트 환경 판단에 왜 isTest() 함수를 사용하지 않았냐면요,,
+    // 이렇게 하는게 유틸 함수 불러와서 사용하는 것보다 조금이나마 빠를 것 같았기 때문입니다.
+    if (process.env.NODE_ENV !== "test") {
+      return;
+    }
+
+    try {
+      const context = Sonamu.getContext();
+      const store = context?.naiteStore;
+
+      if (!store) {
+        return;
+      }
+
+      // 콜스택 수집
+      const stack = extractCallStack();
+
+      const trace: NaiteTrace = {
+        key: name,
+        data: value,
+        stack,
+        at: new Date(),
+      };
+
+      // 항상 배열로 관리
+      const existing = store.get(name) ?? [];
+      store.set(name, [...existing, trace]);
+    } catch {
+      // Context 없는 상황에서 Naite.t 호출
+    }
+  }
+
+  /**
+   * key 또는 wildcard 패턴으로 trace 조회
+   * 항상 NaiteQuery 반환하여 체이닝 가능
+   */
+  get(keyPattern: string): NaiteQuery {
     const context = Sonamu.getContext();
     const store = context?.naiteStore;
 
     if (!store) {
-      return;
+      return new NaiteQuery([]);
     }
-    if (store.has(name)) {
-      // 이미 값이 있는 경우
-      if (Array.isArray(store.get(name))) {
-        // 배열에 추가
-        store.set(name, [...store.get(name), value]);
+
+    // wildcard 없으면 exact match
+    if (!keyPattern.includes("*")) {
+      const traces = store.get(keyPattern) ?? [];
+      return new NaiteQuery(traces);
+    }
+
+    // wildcard 패턴 매칭
+    const allTraces: NaiteTrace[] = [];
+    for (const [key, traces] of store.entries()) {
+      if (matchesPattern(key, keyPattern)) {
+        allTraces.push(...traces);
+      }
+    }
+
+    return new NaiteQuery(allTraces);
+  }
+
+  // 전체 리스트 가져오기
+  getAll(): { [key: string]: any } {
+    const context = Sonamu.getContext();
+    if (!context?.naiteStore) {
+      return {};
+    }
+    // NaiteTrace 배열을 data만 추출하여 반환
+    const result: { [key: string]: any } = {};
+    for (const [key, traces] of context.naiteStore.entries()) {
+      if (key.startsWith("mock:")) {
+        // Mock 설정은 그대로 반환
+        result[key] = traces;
       } else {
-        // 배열이 아닌 경우 배열로 변환
-        store.set(name, [store.get(name), value]);
+        // NaiteTrace 배열은 data만 추출
+        result[key] = traces.map((t: NaiteTrace) => t.data);
       }
-    } else {
-      // 값이 없는 경우 추가
-      store.set(name, value);
     }
+    return result;
   }
 
-  // 테스트에서 값 가져오기
-  static get(name: string): any {
+  /**
+   * 스토어에 들어있던 트레이스를 고대로 꺼내옵니다.
+   * 이때 값들은 모두 직렬화 가능한 상태로 나가게 됩니다.
+   * 테스트 정보와 함께 extensions에 보낼 용도로 만들었습니다.
+   * @returns
+   */
+  getAllTraces(): {
+    key: string;
+    value: any;
+    filePath: string;
+    lineNumber: number;
+    at: string;
+  }[] {
     const context = Sonamu.getContext();
-    if (!context?.naiteStore || !context.naiteStore.has(name)) {
-      throw new Error(`Naite.get: \`${name}\` not found`);
+    if (!context?.naiteStore) {
+      return [];
     }
-    return context?.naiteStore?.get(name);
+
+    const traces = Array.from(context.naiteStore.values()).flat();
+
+    // 직렬화 불가능한 값이 존재한다면 이를 대문짝만하게 알려줍니다! 그치만 알리기만 하고 그냥 지나갑니다 ㅎㅎ
+    // 왜 직렬화가 중요한가? 이(getAllTraces) 호출의 결과는 외부로 나가게 되는데,
+    // 이때 주 용도가 vitest의 task.meta 필드를 통해 afterEach에서 Sonamu extension으로 전달하는 것입니다.
+    // 여기서 meta 필드에 담긴 내용은 프로세스간 통신(process.send) 또는 스레드간 통신(message port)을 통해 전달되어야 하는데,
+    // 이로 인해 "직렬화 가능한 값들만 허용"하는 제약이 생깁니다.
+    //
+    // 이 제약을 의식하여 Naite.t에 직렬화 가능한 값만 넘기게 할 수도 있었지만, 그렇게 하면 불편해질 것 같아서 하지 않았습니다.
+    // 따라서 현재 Naite.t는 모든 값을 받을 수 있게 되어 있습니다. 
+    // 대신 이렇게(getAllTraces) 그 값들을 빼낼 때 JSON.stringify를 사용하여 강제로 직렬화 가능하게 만들었습니다,,
+    for (const trace of traces) {
+      const check = isSerializable(trace.data);
+      if (!check.valid) {
+        console.warn(
+          "\n" +
+            "╔════════════════════════════════════════════════════════════════╗\n" +
+            "║  [Naite] Non-serializable value detected!                      ║\n" +
+            "╠════════════════════════════════════════════════════════════════╣\n" +
+            `║  Key: ${trace.key.padEnd(57)}║\n` +
+            `║  Reason: ${(check.reason ?? "unknown").slice(0, 54).padEnd(54)}║\n` +
+            `║  Location: ${(trace.stack[0]?.filePath ?? "unknown").slice(-51).padEnd(52)}║\n` +
+            `║  Line: ${String(trace.stack[0]?.lineNumber ?? 0).padEnd(56)}║\n` +
+            "╠════════════════════════════════════════════════════════════════╣\n" +
+            "║  Naite.t() accepts any type of value. However, values will     ║\n" +
+            "║  be serialized to JSON when exported via Naite.getAllTraces(). ║\n" +
+            "╚════════════════════════════════════════════════════════════════╝\n",
+        );
+      }
+    }
+
+    return traces.map((trace) => ({
+      key: trace.key,
+      value: JSON.parse(JSON.stringify(trace.data ?? "")), // 직렬화 가능한 것만 남기려는 눈물겨운 노력,, 안그러면 task.meta에 들어가서 프로세스간 통신 할 때 문제 생기거든요,,
+      filePath: trace.stack[0]?.filePath ?? "",
+      lineNumber: trace.stack[0]?.lineNumber ?? 0,
+      at: trace.at.toISOString(),
+    }));
   }
 
-  // 전체 리스트 가져오기
-  static getAll(): { [key: string]: any } {
+  // 특정 키 삭제하기
+  del(key: string) {
     const context = Sonamu.getContext();
     if (!context?.naiteStore) {
-      return {};
+      return;
     }
-    return Object.fromEntries(context.naiteStore.entries());
+    context.naiteStore.delete(key);
   }
 
-  // expect 래퍼 (CJS-ESM 이슈로 현재 사용불가)
-  // static expect(name: string) {
-  //   if (!this.vitestExpect) {
-  //     throw new Error("Vitest is not initialized");
-  //   }
-  //   return this.vitestExpect(this.get(name));
-  // }
+  createStore(): NaiteStore {
+    return new Map<string, NaiteTrace[]>();
+  }
 
   // 일반 로그 레벨
-  static d(_message: string) {
+  d(_message: string) {
     // TODO: Logger 연결
     console.log(`[DEBUG] ${_message}`);
   }
-  static i(_message: string) {
+  i(_message: string) {
     // TODO: Logger 연결
     console.log(`[INFO] ${_message}`);
   }
-  static w(_message: string) {
+  w(_message: string) {
     // TODO: Logger 연결
     console.log(`[WARN] ${_message}`);
   }
-  static e(_message: string) {
+  e(_message: string) {
     // TODO: Logger 연결
     console.log(`[ERROR] ${_message}`);
   }
 }
+
+export const Naite = new NaiteClass();