@simplysm/sd-cli 14.0.38 → 14.0.39

package/src/workers/server-esbuild-context.ts

@@ -1,8 +1,12 @@
+import type ts from "typescript";
 import esbuild from "esbuild";
 import {
   createServerEsbuildOptions,
   writeChangedOutputFiles,
 } from "../esbuild/esbuild-config";
+import { createTscPlugin, type TscPluginResult } from "../esbuild/esbuild-tsc-plugin";
+import type { TypecheckEnv } from "../utils/tsconfig";
+import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 
 /**
  * esbuild watch context 생성 옵션
@@ -12,6 +16,13 @@ export interface EsbuildContextOptions {
   entryPoints: string[];
   env?: Record<string, string>;
   external: string[];
+  /** tsc 플러그인 옵션. 제공 시 createTscPlugin으로 플러그인을 생성하여 esbuild context에 포함한다. */
+  tsc?: {
+    cwd: string;
+    output: { dts: boolean };
+    env?: TypecheckEnv;
+    includeTests?: boolean;
+  };
 }
 
 /** esbuild watch context (모듈 스코프 상태) */
@@ -20,11 +31,24 @@ let context: esbuild.BuildContext | undefined;
 /** 마지막 빌드의 metafile (변경 필터링용) */
 let lastMetafile: esbuild.Metafile | undefined;
 
+/** tsc 플러그인 인스턴스 (모듈 스코프 상태) */
+let tscPlugin: TscPluginResult | undefined;
+
 /**
  * esbuild watch context를 생성한다.
  * dev 모드 전용 (metafile:true, write:false).
  */
 export async function createContext(options: EsbuildContextOptions): Promise<void> {
+  if (options.tsc != null) {
+    tscPlugin = createTscPlugin({
+      pkgDir: options.pkgDir,
+      cwd: options.tsc.cwd,
+      output: options.tsc.output,
+      env: options.tsc.env,
+      includeTests: options.tsc.includeTests,
+    });
+  }
+
   const baseOptions = createServerEsbuildOptions({
     pkgDir: options.pkgDir,
     entryPoints: options.entryPoints,
@@ -35,6 +59,7 @@ export async function createContext(options: EsbuildContextOptions): Promise<voi
 
   context = await esbuild.context({
     ...baseOptions,
+    plugins: tscPlugin != null ? [tscPlugin.plugin] : [],
     metafile: true,
     write: false,
   });
@@ -61,12 +86,14 @@ export async function rebuild(): Promise<{
     await writeChangedOutputFiles(result.outputFiles);
   }
 
-  const errors = result.errors.map((e) => e.text);
+  const esbuildErrors = result.errors.map((e) => e.text);
+  const tscErrors = tscPlugin?.getErrors() ?? [];
+  const allErrors = [...esbuildErrors, ...tscErrors];
   const warnings = result.warnings.map((w) => w.text);
 
   return {
-    success: result.errors.length === 0,
-    errors: errors.length > 0 ? errors : undefined,
+    success: allErrors.length === 0,
+    errors: allErrors.length > 0 ? allErrors : undefined,
     warnings: warnings.length > 0 ? warnings : undefined,
   };
 }
@@ -85,6 +112,10 @@ export async function recreateContext(options: EsbuildContextOptions): Promise<v
   context = undefined;
   lastMetafile = undefined;
 
+  if (tscPlugin != null) {
+    tscPlugin.resetBuilderProgram();
+  }
+
   try {
     await createContext(options);
   } finally {
@@ -101,6 +132,7 @@ export async function dispose(): Promise<void> {
   const contextToDispose = context;
   context = undefined;
   lastMetafile = undefined;
+  tscPlugin = undefined;
 
   if (contextToDispose != null) {
     await contextToDispose.dispose();
@@ -120,3 +152,27 @@ export function getMetafile(): esbuild.Metafile | undefined {
 export function hasContext(): boolean {
   return context != null;
 }
+
+/**
+ * tsc 플러그인의 ts.Program을 반환한다.
+ * 플러그인이 없으면 undefined를 반환한다.
+ */
+export function getTscProgram(): ts.Program | undefined {
+  return tscPlugin?.getProgram();
+}
+
+/**
+ * tsc 플러그인의 affected files를 반환한다.
+ * 플러그인이 없으면 undefined를 반환한다.
+ */
+export function getTscAffectedFiles(): ReadonlySet<string> | undefined {
+  return tscPlugin?.getAffectedFiles();
+}
+
+/**
+ * tsc 플러그인의 diagnostics를 반환한다.
+ * 플러그인이 없으면 빈 배열을 반환한다.
+ */
+export function getTscDiagnostics(): SerializedDiagnostic[] {
+  return tscPlugin?.getDiagnostics() ?? [];
+}

package/tests/angular/client-transform-stylesheet.spec.ts

@@ -118,7 +118,7 @@ describe("createClientTransformStylesheet", () => {
     const deps = new Map<string, Set<string>>();
     const transform = createClientTransformStylesheet({
       loadPaths: [],
-      postCssPlugins: [testPlugin],
+      postcssPlugins: [testPlugin],
       scssErrors: errors,
       scssDependencies: deps,
     });

package/tests/esbuild/esbuild-tsc-plugin.acc.spec.ts

@@ -0,0 +1,349 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type esbuild from "esbuild";
+import type { TscPackageBuildResult } from "../../src/utils/tsc-build";
+
+//#region Mocks
+
+const mockRunTscPackageBuild = vi.fn<(...args: unknown[]) => TscPackageBuildResult>();
+
+vi.mock("../../src/utils/tsc-build", () => ({
+  runTscPackageBuild: (...args: unknown[]) => mockRunTscPackageBuild(...args),
+}));
+
+const mockParseTsconfig = vi.fn();
+
+vi.mock("../../src/utils/tsconfig", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/utils/tsconfig")>();
+  return {
+    ...actual,
+    parseTsconfig: (...args: unknown[]) => mockParseTsconfig(...args),
+  };
+});
+
+//#endregion
+
+const { createTscPlugin } = await import("../../src/esbuild/esbuild-tsc-plugin");
+
+/** esbuild 플러그인 lifecycle을 시뮬레이션하는 헬퍼 */
+function setupPlugin(plugin: esbuild.Plugin) {
+  let onStartCb: (() => esbuild.OnStartResult | null | void | Promise<esbuild.OnStartResult | null | void>) | undefined;
+  let onEndCb: ((result: esbuild.BuildResult) => esbuild.OnEndResult | null | void | Promise<esbuild.OnEndResult | null | void>) | undefined;
+
+  const mockBuild = {
+    onStart(cb: typeof onStartCb) { onStartCb = cb; },
+    onEnd(cb: typeof onEndCb) { onEndCb = cb; },
+  } as unknown as esbuild.PluginBuild;
+
+  void plugin.setup(mockBuild);
+
+  return {
+    async invokeOnStart() {
+      return (await onStartCb?.()) ?? null;
+    },
+    async invokeOnEnd(result?: Partial<esbuild.BuildResult>) {
+      return (await onEndCb?.({
+        errors: [],
+        warnings: [],
+        mangleCache: {},
+        outputFiles: [],
+        metafile: { inputs: {}, outputs: {} },
+        ...result,
+      } as esbuild.BuildResult)) ?? null;
+    },
+  };
+}
+
+const baseOptions = {
+  pkgDir: "/workspace/packages/my-server",
+  cwd: "/workspace",
+  output: { dts: true },
+};
+
+const mockParsedConfig = {
+  options: { target: 99 },
+  fileNames: [],
+  errors: [],
+} as any;
+
+function createSuccessTscResult(): TscPackageBuildResult {
+  return {
+    success: true,
+    diagnostics: [],
+    errorCount: 0,
+    warningCount: 0,
+    program: { getSourceFiles: () => [] } as any,
+    affectedFiles: new Set(["/workspace/packages/my-server/src/main.ts"]),
+    builderProgram: {} as any,
+  };
+}
+
+function createErrorTscResult(): TscPackageBuildResult {
+  return {
+    success: false,
+    errors: ["TS2322: Type 'string' is not assignable to type 'number'"],
+    diagnostics: [{ category: 1, code: 2322, messageText: "Type mismatch" }],
+    errorCount: 1,
+    warningCount: 0,
+    program: { getSourceFiles: () => [] } as any,
+    affectedFiles: new Set(["/workspace/packages/my-server/src/main.ts"]),
+    builderProgram: {} as any,
+  };
+}
+
+describe("createTscPlugin — Acceptance Tests", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockParseTsconfig.mockReturnValue(mockParsedConfig);
+    mockRunTscPackageBuild.mockReturnValue(createSuccessTscResult());
+  });
+
+  // Rule: createTscPlugin은 esbuild.Plugin과 getter 객체를 반환한다
+  describe("Scenario: 필수 옵션으로 플러그인 생성", () => {
+    it('plugin.name이 "sd-tsc"이고 getter 함수들을 반환한다', () => {
+      const result = createTscPlugin(baseOptions);
+
+      expect(result.plugin.name).toBe("sd-tsc");
+      expect(typeof result.plugin.setup).toBe("function");
+      expect(typeof result.getProgram).toBe("function");
+      expect(typeof result.getAffectedFiles).toBe("function");
+      expect(typeof result.getDiagnostics).toBe("function");
+      expect(typeof result.getErrors).toBe("function");
+      expect(typeof result.resetBuilderProgram).toBe("function");
+    });
+  });
+
+  describe("Scenario: 선택 옵션 포함 플러그인 생성", () => {
+    it("env, includeTests 옵션이 runTscPackageBuild에 전달된다", async () => {
+      const result = createTscPlugin({
+        ...baseOptions,
+        env: "node",
+        includeTests: true,
+      });
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+        expect.objectContaining({
+          env: "node",
+          includeTests: true,
+        }),
+      );
+    });
+  });
+
+  // Rule: onStart에서 tsc를 microtask로 스케줄링하고 await하지 않는다
+  describe("Scenario: tsc microtask 스케줄링", () => {
+    it("onStart는 tsc 완료를 기다리지 않고 즉시 반환한다", async () => {
+      const result = createTscPlugin(baseOptions);
+
+      // onStart 콜백을 직접 캡처하여 동기적으로 호출
+      let onStartCb!: () => void;
+      const mockBuild = {
+        onStart(cb: () => void) { onStartCb = cb; },
+        onEnd() { /* noop */ },
+      } as unknown as esbuild.PluginBuild;
+      void result.plugin.setup(mockBuild);
+
+      // onStart 동기 호출 — 반환값이 undefined (await하지 않음)
+      const onStartResult = onStartCb();
+      expect(onStartResult).toBeUndefined();
+
+      // onStart 반환 직후, microtask 전이므로 tsc 미호출
+      expect(mockRunTscPackageBuild).not.toHaveBeenCalled();
+
+      // microtask flush 후 tsc 호출됨
+      await Promise.resolve();
+      expect(mockRunTscPackageBuild).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("Scenario: parsedConfig 갱신", () => {
+    it("매 onStart마다 parseTsconfig를 호출하여 최신 tsconfig를 반영한다", async () => {
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      // 첫 번째 빌드
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      // 두 번째 빌드
+      const updatedConfig = { ...mockParsedConfig, fileNames: ["/new-file.ts"] };
+      mockParseTsconfig.mockReturnValue(updatedConfig);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(mockParseTsconfig).toHaveBeenCalledTimes(2);
+      expect(mockParseTsconfig).toHaveBeenCalledWith(baseOptions.pkgDir);
+      expect(mockRunTscPackageBuild).toHaveBeenLastCalledWith(
+        expect.objectContaining({ parsedConfig: updatedConfig }),
+      );
+    });
+  });
+
+  // Rule: onEnd에서 tsc Promise를 await하여 결과를 내부 상태에 저장한다
+  describe("Scenario: tsc 정상 완료", () => {
+    it("program, affectedFiles, diagnostics를 저장하고 errors는 undefined", async () => {
+      const tscResult = createSuccessTscResult();
+      mockRunTscPackageBuild.mockReturnValue(tscResult);
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(result.getProgram()).toBe(tscResult.program);
+      expect(result.getAffectedFiles()).toBe(tscResult.affectedFiles);
+      expect(result.getDiagnostics()).toEqual([]);
+      expect(result.getErrors()).toBeUndefined();
+    });
+  });
+
+  describe("Scenario: tsc 타입 에러 발생", () => {
+    it("errors를 string[]로, diagnostics를 SerializedDiagnostic[]로 저장한다", async () => {
+      const tscResult = createErrorTscResult();
+      mockRunTscPackageBuild.mockReturnValue(tscResult);
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(result.getErrors()).toEqual(["TS2322: Type 'string' is not assignable to type 'number'"]);
+      expect(result.getDiagnostics()).toEqual([{ category: 1, code: 2322, messageText: "Type mismatch" }]);
+      expect(result.getProgram()).toBe(tscResult.program);
+      expect(result.getAffectedFiles()).toBe(tscResult.affectedFiles);
+    });
+  });
+
+  describe("Scenario: tsc 예외 발생", () => {
+    it("try-catch로 포착하여 errors에 메시지 저장, program/affectedFiles는 undefined", async () => {
+      mockRunTscPackageBuild.mockImplementation(() => {
+        throw new Error("tsconfig parse failed");
+      });
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(result.getErrors()).toEqual(["tsconfig parse failed"]);
+      expect(result.getDiagnostics()).toEqual([]);
+      expect(result.getProgram()).toBeUndefined();
+      expect(result.getAffectedFiles()).toBeUndefined();
+    });
+  });
+
+  // Rule: result.errors에 push하지 않는다
+  describe("Scenario: tsc 에러가 있어도 result.errors는 변경하지 않음", () => {
+    it("onEnd의 result.errors에 tsc 에러를 push하지 않는다", async () => {
+      mockRunTscPackageBuild.mockReturnValue(createErrorTscResult());
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+
+      const buildResult = {
+        errors: [] as esbuild.Message[],
+        warnings: [] as esbuild.Message[],
+      };
+      await lifecycle.invokeOnEnd(buildResult);
+
+      // result.errors는 비어있어야 함 (tsc 에러가 push되지 않음)
+      expect(buildResult.errors).toEqual([]);
+      // tsc 에러는 getErrors()로만 조회 가능
+      expect(result.getErrors()).toBeDefined();
+    });
+  });
+
+  // Rule: getter는 마지막 빌드 결과를 반환한다
+  describe("Scenario: 빌드 전 getter 호출", () => {
+    it("빌드 실행 전 기본값을 반환한다", () => {
+      const result = createTscPlugin(baseOptions);
+
+      expect(result.getProgram()).toBeUndefined();
+      expect(result.getAffectedFiles()).toBeUndefined();
+      expect(result.getDiagnostics()).toEqual([]);
+      expect(result.getErrors()).toBeUndefined();
+    });
+  });
+
+  describe("Scenario: 빌드 후 getter 호출", () => {
+    it("tsc 빌드 성공 후 program과 affectedFiles를 반환한다", async () => {
+      const tscResult = createSuccessTscResult();
+      mockRunTscPackageBuild.mockReturnValue(tscResult);
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(result.getProgram()).toBe(tscResult.program);
+      expect(result.getAffectedFiles()).toEqual(new Set(["/workspace/packages/my-server/src/main.ts"]));
+      expect(result.getDiagnostics()).toEqual([]);
+    });
+  });
+
+  // Rule: lastBuilderProgram을 캐싱하여 watch 모드 증분 빌드를 지원한다
+  describe("Scenario: 증분 빌드 — builderProgram 재사용", () => {
+    it("첫 번째 빌드 후 캐싱된 builderProgram을 두 번째 빌드에 oldBuilderProgram으로 전달한다", async () => {
+      const firstBuilderProgram = { kind: "first" } as any;
+      mockRunTscPackageBuild.mockReturnValue({
+        ...createSuccessTscResult(),
+        builderProgram: firstBuilderProgram,
+      });
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      // 첫 번째 빌드
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      // 두 번째 빌드
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      // 두 번째 호출에서 oldBuilderProgram이 첫 번째 결과의 builderProgram
+      expect(mockRunTscPackageBuild).toHaveBeenCalledTimes(2);
+      expect(mockRunTscPackageBuild).toHaveBeenLastCalledWith(
+        expect.objectContaining({ oldBuilderProgram: firstBuilderProgram }),
+      );
+    });
+  });
+
+  describe("Scenario: builderProgram 리셋", () => {
+    it("resetBuilderProgram 호출 후 다음 빌드는 fresh build로 실행된다", async () => {
+      const cachedBuilderProgram = { kind: "cached" } as any;
+      mockRunTscPackageBuild.mockReturnValue({
+        ...createSuccessTscResult(),
+        builderProgram: cachedBuilderProgram,
+      });
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      // 첫 번째 빌드 — builderProgram 캐싱
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      // 리셋
+      result.resetBuilderProgram();
+
+      // 다음 빌드 — oldBuilderProgram이 undefined (fresh build)
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(mockRunTscPackageBuild).toHaveBeenLastCalledWith(
+        expect.objectContaining({ oldBuilderProgram: undefined }),
+      );
+    });
+  });
+});