@simplysm/sd-cli 14.0.46 → 14.0.48

package/src/typecheck/typecheck-serialization.ts

@@ -2,38 +2,87 @@ import ts from "typescript";
 import { fsx } from "@simplysm/core-node";
 
 /**
- * Worker로 전달할 수 있는 직렬화된 Diagnostic
+ * DiagnosticMessageChain을 worker 경계로 넘기기 위한 직렬화 구조.
+ * (chain 구조를 그대로 보존하여 formatter가 원본 들여쓰기/순서대로 출력하게 함)
+ */
+export interface SerializedMessageChain {
+  messageText: string;
+  category: number;
+  code: number;
+  next?: SerializedMessageChain[];
+}
+
+/**
+ * Worker로 전달할 수 있는 직렬화된 Diagnostic.
+ * ts.Diagnostic의 모든 사용자 가시 필드(detail/relatedInformation/flag)를 보존한다.
  */
 export interface SerializedDiagnostic {
   category: number;
   code: number;
-  messageText: string;
+  /** messageText는 chain(overload 에러 등)이거나 단순 문자열. chain이면 구조 그대로 보존 */
+  messageText: string | SerializedMessageChain;
   file?: {
     fileName: string;
   };
   start?: number;
   length?: number;
+  relatedInformation?: SerializedDiagnosticRelatedInformation[];
+  /** true 또는 ts가 넘기는 (빈) 객체. formatter가 인식. */
+  reportsUnnecessary?: boolean;
+  reportsDeprecated?: boolean;
+  source?: string;
+}
+
+/** ts.DiagnosticRelatedInformation에 대응. file/start/length와 messageText만 가진 축약 구조. */
+export interface SerializedDiagnosticRelatedInformation {
+  category: number;
+  code: number;
+  messageText: string | SerializedMessageChain;
+  file?: { fileName: string };
+  start?: number;
+  length?: number;
+}
+
+function serializeMessageChain(chain: ts.DiagnosticMessageChain): SerializedMessageChain {
+  return {
+    messageText: chain.messageText,
+    category: chain.category,
+    code: chain.code,
+    next: chain.next?.map(serializeMessageChain),
+  };
+}
+
+function serializeMessageText(
+  messageText: string | ts.DiagnosticMessageChain,
+): string | SerializedMessageChain {
+  if (typeof messageText === "string") return messageText;
+  return serializeMessageChain(messageText);
 }
 
 /**
  * Diagnostic을 직렬화 가능한 형태로 변환한다.
  * (Worker 스레드 간 structured clone 통신을 위해 순환 참조/함수를 제거)
+ * messageText chain, relatedInformation, reportsUnnecessary/Deprecated, source 등 모든 detail 보존.
  */
 export function serializeDiagnostic(diagnostic: ts.Diagnostic): SerializedDiagnostic {
-  // DiagnosticMessageChain인 경우 모든 컨텍스트 정보를 보존하기 위해 전체 체인을 평탄화
-  const messageText = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-
   return {
     category: diagnostic.category,
     code: diagnostic.code,
-    messageText,
-    file: diagnostic.file
-      ? {
-          fileName: diagnostic.file.fileName,
-        }
-      : undefined,
+    messageText: serializeMessageText(diagnostic.messageText),
+    file: diagnostic.file != null ? { fileName: diagnostic.file.fileName } : undefined,
     start: diagnostic.start,
     length: diagnostic.length,
+    relatedInformation: diagnostic.relatedInformation?.map((ri) => ({
+      category: ri.category,
+      code: ri.code,
+      messageText: serializeMessageText(ri.messageText),
+      file: ri.file != null ? { fileName: ri.file.fileName } : undefined,
+      start: ri.start,
+      length: ri.length,
+    })),
+    reportsUnnecessary: diagnostic.reportsUnnecessary != null ? true : undefined,
+    reportsDeprecated: diagnostic.reportsDeprecated != null ? true : undefined,
+    source: diagnostic.source,
   };
 }
 
@@ -53,32 +102,57 @@ function getScriptKind(fileName: string): ts.ScriptKind {
  * @param fileCache - 파일 내용 캐시 (같은 파일의 중복 읽기 방지)
  * @returns 복원된 ts.Diagnostic 객체
  */
+function deserializeMessageChain(chain: SerializedMessageChain): ts.DiagnosticMessageChain {
+  return {
+    messageText: chain.messageText,
+    category: chain.category,
+    code: chain.code,
+    next: chain.next?.map(deserializeMessageChain),
+  };
+}
+
+function deserializeMessageText(
+  messageText: string | SerializedMessageChain,
+): string | ts.DiagnosticMessageChain {
+  if (typeof messageText === "string") return messageText;
+  return deserializeMessageChain(messageText);
+}
+
+function loadFile(fileName: string, fileCache: Map<string, string>): ts.SourceFile {
+  if (!fileCache.has(fileName)) {
+    fileCache.set(fileName, fsx.existsSync(fileName) ? fsx.readSync(fileName) : "");
+  }
+  const content = fileCache.get(fileName)!;
+  const scriptKind = getScriptKind(fileName);
+  return ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, false, scriptKind);
+}
+
 export function deserializeDiagnostic(
   serialized: SerializedDiagnostic,
   fileCache: Map<string, string>,
 ): ts.Diagnostic {
-  let file: ts.SourceFile | undefined;
-  if (serialized.file != null) {
-    const fileName = serialized.file.fileName;
+  const file = serialized.file != null ? loadFile(serialized.file.fileName, fileCache) : undefined;
 
-    // 캐시된 파일 내용 가져오기 (없으면 읽어서 캐시)
-    // 파일이 삭제되었거나 접근 불가능하면 빈 내용으로 처리
-    // (소스 코드 컨텍스트는 표시되지 않지만 진단 메시지는 정상 표시됨)
-    if (!fileCache.has(fileName)) {
-      fileCache.set(fileName, fsx.existsSync(fileName) ? fsx.readSync(fileName) : "");
-    }
-    const content = fileCache.get(fileName)!;
-
-    const scriptKind = getScriptKind(fileName);
-    file = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, false, scriptKind);
-  }
+  const relatedInformation: ts.DiagnosticRelatedInformation[] | undefined =
+    serialized.relatedInformation?.map((ri) => ({
+      category: ri.category,
+      code: ri.code,
+      messageText: deserializeMessageText(ri.messageText),
+      file: ri.file != null ? loadFile(ri.file.fileName, fileCache) : undefined,
+      start: ri.start,
+      length: ri.length,
+    }));
 
   return {
     category: serialized.category,
     code: serialized.code,
-    messageText: serialized.messageText,
+    messageText: deserializeMessageText(serialized.messageText),
     file,
     start: serialized.start,
     length: serialized.length,
+    relatedInformation,
+    reportsUnnecessary: serialized.reportsUnnecessary === true ? {} : undefined,
+    reportsDeprecated: serialized.reportsDeprecated === true ? {} : undefined,
+    source: serialized.source,
   };
 }

package/src/utils/output-utils.ts

@@ -1,8 +1,8 @@
 import { formatMessagesSync, type PartialMessage } from "esbuild";
-import { consola } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type { BuildResult } from "../runtime/ResultCollector";
 
-const logger = consola.withTag("sd:cli:output");
+const logger = createLazyLogger("sd:cli:output");
 
 /**
  * esbuild Message 배열을 포맷된 문자열 배열로 변환한다.

package/src/utils/package-classify.ts

@@ -1,6 +1,6 @@
 import path from "path";
-import { consola } from "consola";
 import { pathx } from "@simplysm/core-node";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type {
   BuildTarget,
   SdBuildPackageConfig,
@@ -10,7 +10,7 @@ import type {
   SdServerPackageConfig,
 } from "../sd-config.types";
 
-const logger = consola.withTag("sd:cli:package-classify");
+const logger = createLazyLogger("sd:cli:package-classify");
 
 /**
  * 패키지 config를 순회하며 null 필터링 + target 필터링을 수행한다.

package/src/utils/package-utils.ts

@@ -1,14 +1,14 @@
 import path from "path";
 import fs from "fs";
-import { consola } from "consola";
 import { SdError } from "@simplysm/core-common";
 import { pathx } from "@simplysm/core-node";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type {
   SdBuildPackageConfig,
   SdPackageConfig,
 } from "../sd-config.types";
 
-const logger = consola.withTag("sd:cli:package-utils");
+const logger = createLazyLogger("sd:cli:package-utils");
 
 /**
  * import.meta.dirname에서 위로 탐색하여 package.json을 찾고 패키지 루트를 반환한다.

package/src/utils/sd-config.ts

@@ -1,10 +1,10 @@
 import { createJiti } from "jiti";
 import { SdError } from "@simplysm/core-common";
 import { fsx, pathx } from "@simplysm/core-node";
-import { consola } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type { SdConfig, SdConfigParams } from "../sd-config.types";
 
-const logger = consola.withTag("sd:cli:sd-config");
+const logger = createLazyLogger("sd:cli:sd-config");
 
 /**
  * sd.config.ts를 로드한다.

package/src/utils/tsconfig.ts

@@ -2,9 +2,9 @@ import path from "path";
 import fs from "fs";
 import ts from "typescript";
 import { pathx } from "@simplysm/core-node";
-import { consola } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 
-const logger = consola.withTag("sd:cli:tsconfig");
+const logger = createLazyLogger("sd:cli:tsconfig");
 
 //#region TypecheckEnv
 
@@ -110,10 +110,9 @@ export function getPackageSourceFiles(
   const srcDir = path.join(pkgDir, "src");
   const files = parsedConfig.fileNames.filter((f) => {
     if (pathx.isChildPath(f, srcDir)) return true;
-    if (f.endsWith(".fixture.ts")) return true;
     return false;
   });
-  logger.debug(`소스 파일 필터링: ${parsedConfig.fileNames.length}개 중 ${files.length}개 (src/ + fixtures)`);
+  logger.debug(`소스 파일 필터링: ${parsedConfig.fileNames.length}개 중 ${files.length}개 (src/ only)`);
   return files;
 }
 

package/tests/esbuild/esbuild-worker-plugin.spec.ts

@@ -28,6 +28,36 @@ function createMockBuild(overrides?: Partial<esbuild.BuildOptions>): esbuild.Plu
   } as unknown as esbuild.PluginBuild;
 }
 
+/**
+ * transformSync 호출을 추적할 수 있도록 esbuild 네임스페이스를 wrap한다.
+ * vi.spyOn이 ESM namespace frozen property에서 실패하므로 대안으로 사용한다.
+ */
+function createTrackedBuild(overrides?: Partial<esbuild.BuildOptions>): {
+  build: esbuild.PluginBuild;
+  transformSyncCalls: Array<Parameters<typeof esbuild.transformSync>>;
+} {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-unit-"));
+  const transformSyncCalls: Array<Parameters<typeof esbuild.transformSync>> = [];
+  const trackedEsbuild = {
+    ...esbuild,
+    transformSync: (...args: Parameters<typeof esbuild.transformSync>) => {
+      transformSyncCalls.push(args);
+      return esbuild.transformSync(...args);
+    },
+  } as typeof esbuild;
+
+  const build = {
+    esbuild: trackedEsbuild,
+    initialOptions: {
+      outdir: tmpDir,
+      write: false,
+      ...overrides,
+    },
+  } as unknown as esbuild.PluginBuild;
+
+  return { build, transformSyncCalls };
+}
+
 describe("transformWorkerPatterns — 패턴 감지", () => {
   it("Worker 패턴이 없는 content에 대해 undefined를 반환한다", () => {
     const result = transformWorkerPatterns(
@@ -446,6 +476,14 @@ const x = 1;`,
 
     expect(matches).toHaveLength(0);
   });
+
+  it("래퍼 함수를 통한 Worker 생성은 탐지하지 않는다", () => {
+    const matches = findWorkerPatterns(
+      `const w = createBrowserWorker(new URL("./worker.js", import.meta.url), { type: "module" });`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
 });
 
 describe("transformWorkerPatterns — TypeScript 파일 처리", () => {
@@ -604,3 +642,210 @@ const w = new Worker(new URL("./worker.js", import.meta.url));`,
     expect(result.contents).toMatch(/worker-[a-z0-9]+\.js/i);
   });
 });
+
+describe("transformWorkerPatterns — skipTsTransform 옵션", () => {
+  it("skipTsTransform: true + .ts 경로 + JS content → transformSync 호출 없이 정상 치환", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    // ngtsc emit 결과를 흉내: 파일 경로는 .ts이지만 content는 이미 JS
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      { skipTsTransform: true },
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("skipTsTransform: true + .ts 경로 + 실제 TS 구문 → 계약 위반으로 undefined (조용한 누락)", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    // 호출자가 계약을 위반하여 실제 TS 구문을 넘긴 경우:
+    // transformSync가 스킵되므로 acorn이 TS 구문 파싱 실패 → 빈 matches → undefined
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      { skipTsTransform: true },
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+
+  it("옵션 생략 + .ts + import type + Worker → transformSync 호출 후 정상 감지 (후방 호환)", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(1);
+    expect(transformSyncCalls[0][1]).toMatchObject({ loader: "ts" });
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("옵션 { skipTsTransform: false } → 기본 동작 (transformSync 호출)", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      { skipTsTransform: false },
+    );
+
+    expect(transformSyncCalls).toHaveLength(1);
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("빈 객체 {} → skipTsTransform undefined → 기본 동작 (transformSync 호출)", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      {},
+    );
+
+    expect(transformSyncCalls).toHaveLength(1);
+    expect(result).toBeDefined();
+  });
+
+  it("skipTsTransform: true + .js 경로 → 동작 동일 (확장자 분기 진입 안 함)", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      { skipTsTransform: true },
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+});
+
+describe("transformWorkerPatterns — 사전 필터 정규식 경계", () => {
+  it("타입 어노테이션만 등장한 Worker 키워드 → 사전 필터 차단", () => {
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `const x: Worker = 1 as any;`,
+      path.join(fixturesDir, "entry.ts"),
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+
+  it("interface 선언에만 등장한 Worker → 사전 필터 차단", () => {
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `interface WorkerLike { run(): void; }`,
+      path.join(fixturesDir, "entry.ts"),
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+
+  it("import type에만 등장한 Worker → 사전 필터 차단", () => {
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `import type { Worker } from "./types";`,
+      path.join(fixturesDir, "entry.ts"),
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+
+  it("new Worker 호출 → 사전 필터 통과, AST 감지", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("new SharedWorker 호출 → 사전 필터 통과, AST 감지", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const result = transformWorkerPatterns(
+      `const sw = new SharedWorker(new URL("./shared-worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("import.meta.resolve 호출 → 사전 필터 통과, AST 감지", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("./node-worker.js");`,
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(
+      /new URL\("worker-[a-z0-9]+\.js", import\.meta\.url\)\.href/i,
+    );
+  });
+
+  it("new  Worker (연속 공백) → 사전 필터 통과", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const result = transformWorkerPatterns(
+      `const w = new   Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+  });
+
+  it("WorkerSubClass 식별자 (단어 경계 위반) → 사전 필터 차단", () => {
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `class WorkerSubClass {}\nconst x = new WorkerSubClass();`,
+      path.join(fixturesDir, "entry.ts"),
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+});

package/tests/utils/replace-deps-watch.acc.spec.ts

@@ -134,4 +134,89 @@ describe("watchReplaceDeps onChanged 콜백", () => {
     // 콜백 호출 대기
     await changedPromise;
   }, 10_000);
+
+  it("동일 source를 참조하는 복수 entry가 있으면 모든 target에 복사된다", async () => {
+    // 추가 target 디렉토리 생성 (@test/pkgB)
+    const targetDirB = path.join(tmpDir, "project", "node_modules", "@test", "pkgB", "src");
+    await fs.promises.mkdir(targetDirB, { recursive: true });
+    await fs.promises.writeFile(path.join(targetDirB, "index.ts"), "export const a = 1;");
+
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+
+    // 두 패턴이 동일 sourcePath를 참조
+    const replaceDeps = {
+      "@test/pkg": sourcePath,
+      "@test/pkgB": sourcePath,
+    };
+
+    let callCount = 0;
+    watchResult = await watchReplaceDeps(projectRoot, replaceDeps, {
+      onChanged: () => {
+        callCount++;
+      },
+    });
+
+    // 소스 파일 변경
+    await fs.promises.writeFile(
+      path.join(sourcePath, "src", "index.ts"),
+      "export const a = 9;",
+    );
+
+    // 배칭 + 복사 완료 대기
+    await new Promise((r) => setTimeout(r, 1500));
+
+    // 두 target 모두 업데이트
+    const targetAContent = await fs.promises.readFile(
+      path.join(tmpDir, "project", "node_modules", "@test", "pkg", "src", "index.ts"),
+      "utf-8",
+    );
+    const targetBContent = await fs.promises.readFile(
+      path.join(targetDirB, "index.ts"),
+      "utf-8",
+    );
+    expect(targetAContent).toBe("export const a = 9;");
+    expect(targetBContent).toBe("export const a = 9;");
+
+    // 동일 source의 중복 watchPath는 하나로 통합되므로 이벤트가 1회만 배칭됨 → onChanged 1회
+    expect(callCount).toBe(1);
+  }, 10_000);
+
+  it("소스 파일이 삭제되면 대상 파일도 삭제된다", async () => {
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+    const replaceDeps = { "@test/pkg": sourcePath };
+
+    let resolveChanged: () => void;
+    const changedPromise = new Promise<void>((resolve) => {
+      resolveChanged = resolve;
+    });
+
+    watchResult = await watchReplaceDeps(projectRoot, replaceDeps, {
+      onChanged: () => {
+        resolveChanged();
+      },
+    });
+
+    const destPath = path.join(
+      tmpDir, "project", "node_modules", "@test", "pkg", "src", "index.ts",
+    );
+
+    // 삭제 전 target 파일 존재 확인
+    await expect(fs.promises.access(destPath)).resolves.toBeUndefined();
+
+    // 소스 삭제
+    await fs.promises.unlink(path.join(sourcePath, "src", "index.ts"));
+
+    await changedPromise;
+
+    // 삭제 반영까지 여유 대기
+    await new Promise((r) => setTimeout(r, 500));
+
+    // target도 삭제됨
+    const targetExists = await fs.promises
+      .access(destPath)
+      .then(() => true, () => false);
+    expect(targetExists).toBe(false);
+  }, 10_000);
 });