sonamu 0.6.0 → 0.7.1

package/dist/naite/naite.d.ts

@@ -1,12 +1,95 @@
-export declare class Naite {
-    static t(name: string, value: any): void;
-    static get(name: string): any;
-    static getAll(): {
+/** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */
+import type { ComparisonOperator } from "../database/puri.types";
+interface StackFrame {
+    functionName: string | null;
+    filePath: string;
+    lineNumber: number;
+}
+interface NaiteTrace {
+    key: string;
+    data: any;
+    stack: StackFrame[];
+    at: Date;
+}
+export type NaiteStore = Map<string, NaiteTrace[]>;
+/**
+ * NaiteQuery 클래스
+ * 체이닝을 통한 trace 필터링 및 조회
+ */
+export declare class NaiteQuery {
+    private traces;
+    constructor(traces: NaiteTrace[]);
+    /**
+     * 파일명으로 필터링
+     * @param fileName 파일명 (예: "syncer.test.ts")
+     */
+    fromFile(fileName: string): NaiteQuery;
+    /**
+     * 함수명으로 필터링
+     * @param funcName 함수명 (includes 체크)
+     * @param options.from 'direct' = 직접 호출만, 'indirect' = 간접 호출만, 'both' = 모두
+     */
+    fromFunction(funcName: string, options?: {
+        from: "direct" | "indirect" | "both";
+    }): NaiteQuery;
+    /**
+     * 데이터 경로 기반 필터링
+     * @param path radash get 경로 (예: "data.userId")
+     * @param operator 비교 연산자
+     * @param value 비교값
+     */
+    where(path: string, operator: ComparisonOperator | "includes", value: any): NaiteQuery;
+    /**
+     * 전체 데이터 배열 반환
+     */
+    result(): any[];
+    /**
+     * 첫 번째 데이터 반환
+     */
+    first(): any | undefined;
+    /**
+     * 마지막 데이터 반환
+     */
+    last(): any | undefined;
+    /**
+     * n번째 데이터 반환
+     */
+    at(index: number): any | undefined;
+    /**
+     * 원본 trace 배열 반환 (디버깅/NaiteViewer용)
+     */
+    getTraces(): NaiteTrace[];
+}
+export declare class NaiteClass {
+    t(name: string, value: any): void;
+    /**
+     * key 또는 wildcard 패턴으로 trace 조회
+     * 항상 NaiteQuery 반환하여 체이닝 가능
+     */
+    get(keyPattern: string): NaiteQuery;
+    getAll(): {
         [key: string]: any;
     };
-    static d(_message: string): void;
-    static i(_message: string): void;
-    static w(_message: string): void;
-    static e(_message: string): void;
+    /**
+     * 스토어에 들어있던 트레이스를 고대로 꺼내옵니다.
+     * 이때 값들은 모두 직렬화 가능한 상태로 나가게 됩니다.
+     * 테스트 정보와 함께 extensions에 보낼 용도로 만들었습니다.
+     * @returns
+     */
+    getAllTraces(): {
+        key: string;
+        value: any;
+        filePath: string;
+        lineNumber: number;
+        at: string;
+    }[];
+    del(key: string): void;
+    createStore(): NaiteStore;
+    d(_message: string): void;
+    i(_message: string): void;
+    w(_message: string): void;
+    e(_message: string): void;
 }
+export declare const Naite: NaiteClass;
+export {};
 //# sourceMappingURL=naite.d.ts.map

package/dist/naite/naite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"naite.d.ts","sourceRoot":"","sources":["../../src/naite/naite.ts"],"names":[],"mappings":"AAEA,qBAAa,KAAK;IAEhB,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAuBjC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG;IAS7B,MAAM,CAAC,MAAM,IAAI;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE;IAiBvC,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIzB,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIzB,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIzB,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM;CAI1B"}
+{"version":3,"file":"naite.d.ts","sourceRoot":"","sources":["../../src/naite/naite.ts"],"names":[],"mappings":"AAAA,oFAAoF;AAIpF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAIjE,UAAU,UAAU;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAGD,UAAU,UAAU;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,EAAE,EAAE,IAAI,CAAC;CACV;AAGD,MAAM,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;AAsGnD;;;GAGG;AACH,qBAAa,UAAU;IACT,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,UAAU,EAAE;IAExC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU;IAOtC;;;;OAIG;IACH,YAAY,CACV,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;QAAE,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAA;KAAqB,GACnE,UAAU;IAgBb;;;;;OAKG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,GAAG,UAAU,EAAE,KAAK,EAAE,GAAG,GAAG,UAAU;IA0BtF;;OAEG;IACH,MAAM,IAAI,GAAG,EAAE;IAIf;;OAEG;IACH,KAAK,IAAI,GAAG,GAAG,SAAS;IAIxB;;OAEG;IACH,IAAI,IAAI,GAAG,GAAG,SAAS;IAIvB;;OAEG;IACH,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS;IAIlC;;OAEG;IACH,SAAS,IAAI,UAAU,EAAE;CAG1B;AAGD,qBAAa,UAAU;IAErB,CAAC,CACC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,GAAG;IAmCZ;;;OAGG;IACH,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU;IA0BnC,MAAM,IAAI;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE;IAmBhC;;;;;OAKG;IACH,YAAY,IAAI;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,GAAG,CAAC;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,EAAE,EAAE,MAAM,CAAC;KACZ,EAAE;IA+CH,GAAG,CAAC,GAAG,EAAE,MAAM;IAQf,WAAW,IAAI,UAAU;IAKzB,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIlB,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIlB,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIlB,CAAC,CAAC,QAAQ,EAAE,MAAM;CAInB;AAED,eAAO,MAAM,KAAK,YAAmB,CAAC"}

package/dist/naite/naite.js

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

package/dist/stream/sse.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import type { FastifyRequest, FastifyReply } from "fastify";
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { z } from "zod";
 export declare function createSSEFactory<T extends z.ZodObject>(socket: FastifyRequest["socket"], reply: FastifyReply, _events: T): SSEConnection<T>;
 declare class SSEConnection<T extends z.ZodObject> {
     private readonly socket;

package/dist/stream/sse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/stream/sse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5D,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EACpD,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,EAChC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,CAAC,oBAGX;AAED,cAAM,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;IAIrC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,OAAO,CAAC,OAAO,CAAS;gBAGL,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,EAChC,KAAK,EAAE,YAAY;IAOtC,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAWlE,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAa3B"}
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/stream/sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAG7B,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EACpD,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,EAChC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,CAAC,oBAGX;AAED,cAAM,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;IAIrC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,OAAO,CAAC,OAAO,CAAS;gBAGL,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,EAChC,KAAK,EAAE,YAAY;IAOtC,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAWlE,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAa3B"}

package/dist/stream/sse.js

@@ -35,4 +35,4 @@ class SSEConnection {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/syncer/api-parser.d.ts

@@ -1,20 +1,10 @@
-import { ApiParam, ApiParamType } from "../types/types";
-import { AbsolutePath } from "../utils/path-utils";
+import { type ExtendedApi } from "../api/decorators";
+import type { AbsolutePath } from "../utils/path-utils";
 /**
  * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
  * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
  * @param filePath - 파싱할 TypeScript 파일의 절대 경로
  * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)
  */
-export declare function readApisFromFile(filePath: AbsolutePath): Promise<{
-    typeParameters: ApiParamType.TypeParam[];
-    parameters: ApiParam[];
-    returnType: ApiParamType;
-    modelName: string;
-    methodName: string;
-    path: string;
-    options: import("..").ApiDecoratorOptions;
-    streamOptions?: import("..").StreamDecoratorOptions;
-    uploadOptions?: import("..").UploadDecoratorOptions;
-}[]>;
+export declare function readApisFromFile(filePath: AbsolutePath): Promise<ExtendedApi[]>;
 //# sourceMappingURL=api-parser.d.ts.map

package/dist/syncer/api-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-parser.d.ts","sourceRoot":"","sources":["../../src/syncer/api-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAOxD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,YAAY;;;;;;;;;;KA4G5D"}
+{"version":3,"file":"api-parser.d.ts","sourceRoot":"","sources":["../../src/syncer/api-parser.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAGrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAwGrF"}