@simplysm/sd-cli 14.0.29 → 14.0.32

package/tests/engines/esbuild-client-engine.spec.ts

@@ -0,0 +1,320 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// --- Mock factories (vi.mock is hoisted) ---
+
+const mockWorker = {
+  build: vi.fn(),
+  startWatch: vi.fn(),
+  stopWatch: vi.fn(),
+  terminate: vi.fn(),
+  on: vi.fn(),
+};
+
+vi.mock("@simplysm/core-node", () => ({
+  Worker: {
+    create: vi.fn(() => mockWorker),
+  },
+}));
+
+// fs mock
+const mockUnlinkSync = vi.fn();
+vi.mock("node:fs", () => ({
+  default: {
+    unlinkSync: (...args: any[]) => mockUnlinkSync(...args),
+  },
+  unlinkSync: (...args: any[]) => mockUnlinkSync(...args),
+}));
+
+// --- Dynamic imports after mocking ---
+
+const { EsbuildClientEngine } = await import("../../src/engines/EsbuildClientEngine");
+
+import type { ClientPackageInfo } from "../../src/engines/types";
+
+// --- Helpers ---
+
+function createMockPkg(overrides: Partial<ClientPackageInfo> = {}): ClientPackageInfo {
+  return {
+    name: "my-client",
+    dir: "/packages/my-client",
+    config: { target: "client", server: "my-server" } as any,
+    ...overrides,
+  };
+}
+
+// --- Tests ---
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockWorker.terminate.mockResolvedValue(undefined);
+  mockWorker.stopWatch.mockResolvedValue(undefined);
+});
+
+describe("EsbuildClientEngine", () => {
+  describe("run()", () => {
+    it("worker.build()에 ClientBuildInfo를 전달한다", async () => {
+      mockWorker.build.mockResolvedValue({ success: true });
+
+      const pkg = createMockPkg({
+        config: {
+          target: "client",
+          server: "my-server",
+          env: { API_URL: "http://localhost" },
+          configs: { key: "value" },
+          pwa: false,
+        } as any,
+      });
+
+      const engine = new EsbuildClientEngine({
+        cwd: "/root",
+        pkg,
+        outDir: "/custom/out",
+        base: "/app/",
+      });
+
+      await engine.run({ js: true, dts: false });
+
+      expect(mockWorker.build).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "my-client",
+          cwd: "/root",
+          pkgDir: "/packages/my-client",
+          env: { API_URL: "http://localhost" },
+          configs: { key: "value" },
+          pwa: false,
+          outDir: "/custom/out",
+          base: "/app/",
+        }),
+      );
+
+      // framework 필드가 포함되지 않아야 한다 (D3)
+      const buildArg = mockWorker.build.mock.calls[0][0];
+      expect(buildArg).not.toHaveProperty("framework");
+
+      // exclude 필드가 포함되지 않아야 한다 (D4)
+      expect(buildArg).not.toHaveProperty("exclude");
+
+      await engine.stop();
+    });
+
+    it("browserSupport를 worker.build()에 전달한다", async () => {
+      mockWorker.build.mockResolvedValue({ success: true });
+
+      const browserSupport = {
+        legacyModule: true,
+        browserslist: "Chrome 61",
+        postCss: { plugins: [["autoprefixer"] as [string]] },
+      };
+      const pkg = createMockPkg({
+        config: {
+          target: "client",
+          server: "my-server",
+          browserSupport,
+        } as any,
+      });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg });
+      await engine.run({ js: true, dts: false });
+
+      expect(mockWorker.build).toHaveBeenCalledWith(
+        expect.objectContaining({ browserSupport }),
+      );
+
+      await engine.stop();
+    });
+
+    it("빌드 실패 시 에러를 EngineResult에 매핑한다", async () => {
+      mockWorker.build.mockResolvedValue({
+        success: false,
+        errors: ["TS2345: Type error"],
+        warnings: ["deprecation warning"],
+      });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: false });
+
+      expect(result.build.success).toBe(false);
+      expect(result.build.errors).toContain("TS2345: Type error");
+      expect(result.build.warnings).toContain("deprecation warning");
+
+      await engine.stop();
+    });
+
+    it("errors/warnings가 undefined이면 빈 배열로 매핑한다", async () => {
+      mockWorker.build.mockResolvedValue({ success: true });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: false });
+
+      expect(result.build.errors).toEqual([]);
+      expect(result.build.warnings).toEqual([]);
+
+      await engine.stop();
+    });
+  });
+
+  describe("startWatch()", () => {
+    it("server가 number이면 포트로 전달한다", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const pkg = createMockPkg({
+        config: { target: "client", server: 4200 } as any,
+      });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg });
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(mockWorker.startWatch).toHaveBeenCalledWith(
+        expect.objectContaining({ port: 4200 }),
+      );
+
+      await engine.stop();
+    });
+
+    it("browserSupport를 worker.startWatch()에 전달한다", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const browserSupport = { browserslist: ["Chrome 61", "Firefox 60"] };
+      const pkg = createMockPkg({
+        config: { target: "client", server: 4200, browserSupport } as any,
+      });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg });
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(mockWorker.startWatch).toHaveBeenCalledWith(
+        expect.objectContaining({ browserSupport }),
+      );
+
+      await engine.stop();
+    });
+
+    it("server가 string이면 port를 undefined로 전달한다", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new EsbuildClientEngine({
+        cwd: "/root",
+        pkg: createMockPkg({ config: { target: "client", server: "my-server" } as any }),
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(mockWorker.startWatch).toHaveBeenCalledWith(
+        expect.objectContaining({ port: undefined }),
+      );
+
+      await engine.stop();
+    });
+
+    it("error 이벤트를 ResultCollector에 보고한다", async () => {
+      const mockResultCollector = { add: vi.fn() };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        const errorHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "error",
+        )?.[1];
+        errorHandler?.({ message: "Build failed" });
+        return Promise.resolve({ success: false });
+      });
+
+      const engine = new EsbuildClientEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      const errorResult = mockResultCollector.add.mock.calls.find(
+        (c: any[]) => c[0].status === "error",
+      );
+      expect(errorResult).toBeDefined();
+      expect(errorResult![0].message).toBe("Build failed");
+
+      await engine.stop();
+    });
+
+    it("RebuildManager에 '{name}:build' 키 패턴으로 등록한다", async () => {
+      const mockRebuildManager = { registerBuild: vi.fn(() => vi.fn()) };
+
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new EsbuildClientEngine({
+        cwd: "/root",
+        pkg: createMockPkg({ name: "demo-app" }),
+        rebuildManager: mockRebuildManager as any,
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      const buildStartHandler = mockWorker.on.mock.calls.find(
+        (call: any[]) => call[0] === "buildStart",
+      )?.[1];
+      buildStartHandler?.({});
+
+      expect(mockRebuildManager.registerBuild).toHaveBeenCalledWith(
+        "demo-app:build",
+        expect.any(String),
+      );
+
+      await engine.stop();
+    });
+
+    it("port가 없으면 serverReady 전까지 undefined이다", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(engine.port).toBeUndefined();
+
+      await engine.stop();
+    });
+
+    it("scopeRebuild 이벤트를 구독하지 않는다", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.startWatch({ js: true, dts: false });
+
+      const scopeRebuildSubscription = mockWorker.on.mock.calls.find(
+        (call: any[]) => call[0] === "scopeRebuild",
+      );
+      expect(scopeRebuildSubscription).toBeUndefined();
+
+      await engine.stop();
+    });
+  });
+
+  describe("stop()", () => {
+    it("run 모드에서는 stopWatch를 호출하지 않는다", async () => {
+      mockWorker.build.mockResolvedValue({ success: true });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.run({ js: true, dts: false });
+      await engine.stop();
+
+      expect(mockWorker.stopWatch).not.toHaveBeenCalled();
+      expect(mockWorker.terminate).toHaveBeenCalled();
+    });
+
+    it("worker 생성 전 stop() 호출을 안전하게 처리한다", async () => {
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+      await expect(engine.stop()).resolves.toBeUndefined();
+    });
+
+    it(".dev-port 파일 삭제 실패를 무시한다", async () => {
+      mockUnlinkSync.mockImplementation(() => {
+        throw new Error("ENOENT");
+      });
+
+      mockWorker.build.mockResolvedValue({ success: true });
+
+      const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.run({ js: true, dts: false });
+
+      // 예외 없이 stop 완료
+      await expect(engine.stop()).resolves.toBeUndefined();
+    });
+  });
+});

package/tests/engines/esbuild-client-engine.verify.md

@@ -0,0 +1,15 @@
+# EsbuildClientEngine Slice 1 — LLM 검증
+
+## 검증 항목
+
+- [x] legacy 프로덕션 빌드: client.worker.ts build()에서 `legacyModule` 플래그가 resolvePackageInfo()를 통해 sd.config.ts에서 읽히고 createClientEsbuildContext()에 전달됨 (line 100, 124). esbuild-client-config.ts에서 splitting:false, import-meta:false 적용 확인 (line 160, 171)
+- [x] legacy dev watch: startWatch()에서 동일하게 legacyModule이 전달되고 (line 224), legacyModule=true 시 templateUpdates를 undefined로 전달하여 Angular HMR banner를 비활성화 (line 227). CSS swap + full-reload만 동작
+- [x] device 호환성 (.dev-port): startWatch()에서 포트 할당 후 dist/.dev-port에 기록 (line 319). EsbuildClientEngine.stop()에서 .dev-port 삭제 (line 153-154)
+- [x] device 호환성 (dist/ 구조): esbuild가 dist/에 직접 write:true로 출력 (esbuild-client-config.ts line 163). Capacitor/Electron이 dist/에서 접근 가능한 구조 유지
+- [x] framework 필드 제거: SdClientPackageConfig에서 framework 필드 삭제됨 (sd-config.types.ts 확인). ClientBuildInfo에서 framework 필드 삭제됨 (client.worker.ts line 27-42). EsbuildClientEngine.run()에서 framework을 worker에 전달하지 않음
+- [x] ClientBuildInfo.exclude 제거: ClientBuildInfo에 exclude 필드 없음 (client.worker.ts line 27-42). SdClientPackageConfig.exclude는 Capacitor/Electron용으로 유지
+- [x] scopeRebuild 이벤트 제거: ClientWorkerEvents에 scopeRebuild 없음 (client.worker.ts line 53-58). EsbuildClientEngine에서 scopeRebuild 이벤트 구독 안 함 (자동 테스트로도 검증)
+- [x] .config.json 기록: build()에서 writeConfigJson() 호출 (line 169). startWatch()에서 writeConfigJson() 호출 (line 318)
+- [x] 팩토리 교체: engines/index.ts에서 ViteEngine → EsbuildClientEngine으로 교체 확인. import 및 생성자 호출 모두 EsbuildClientEngine 사용
+- [x] stopWatch 리소스 정리 순서: esbuild context dispose → HMR close → HTTP server close → public watcher close (line 332-360). 구현계획의 순서와 일치
+- [!] resolvePackageInfo의 dev 고정값: build()에서도 `dev: true`로 loadSdConfig를 호출함 (line 82). build 모드에서는 `dev: false`여야 할 수 있으나, 기존 ViteEngine도 동일한 패턴이므로 기존 동작 유지. 별도 수정 불요

package/tests/engines/normalize-result.verify.md

@@ -0,0 +1,9 @@
+# _normalizeResult 서브클래스 사용 — LLM 검증
+
+## 검증 항목
+
+- [x] TscEngine._callBuild()가 this._normalizeResult(result)를 호출한다: TscEngine.ts:56 확인 — `return this._normalizeResult(result);`
+- [x] NgtscEngine._callBuild()가 this._normalizeResult(result)를 호출한다: NgtscEngine.ts:55 확인 — `return this._normalizeResult(result);`
+- [x] ServerEsbuildEngine._callBuild()가 this._normalizeResult(result)를 호출한다: ServerEsbuildEngine.ts:60 확인 — `return this._normalizeResult(result);`
+- [x] BaseEngine._normalizeResult()의 입력 타입이 Worker 반환 구조와 호환된다: build.errors?/warnings?가 optional이고, diagnostics가 SerializedDiagnostic[]로 일치
+- [x] 3개 서브클래스에서 인라인 normalization 코드가 완전히 제거되었다: 각 파일에서 `result.build.errors ??` 패턴이 더 이상 없음

package/tests/engines/vite-dependency-cleanup.verify.md

@@ -0,0 +1,24 @@
+# Vite 빌드 의존성 정리 — LLM 검증
+
+## 검증 항목
+
+### Scenario: 빌드 전용 Vite 플러그인 의존성 제거
+- [x] vite-plugin-pwa가 package.json dependencies에서 제거됨: package.json에 vite-plugin-pwa 미존재 확인
+- [x] vite-plugin-solid가 package.json dependencies에서 제거됨: package.json에 vite-plugin-solid 미존재 확인
+
+### Scenario: Vitest용 Vite 의존성을 devDependencies로 이동
+- [x] vite가 devDependencies에 존재하고 dependencies에 없음: package.json:55 `"vite": "^7.3.2"` in devDependencies
+- [x] vite-tsconfig-paths가 devDependencies에 존재하고 dependencies에 없음: package.json:56 `"vite-tsconfig-paths": "^6.1.1"` in devDependencies
+
+### Scenario: workbox 관련 타입 정리
+- [x] SdPwaWorkboxConfig 인터페이스가 sd-config.types.ts에서 삭제됨: grep "SdPwaWorkboxConfig" → No matches found
+- [x] SdPwaConfig에서 workbox 필드가 삭제됨: grep "workbox" → No matches found
+- [x] pnpm typecheck sd-cli 통과: 0개 에러, 0개 경고
+
+### Scenario: ViteEngine.ts 삭제
+- [x] engines/ViteEngine.ts 파일이 존재하지 않음: `test -f` → DELETED
+- [x] engines/index.ts에서 ViteEngine 미참조: grep "ViteEngine" engines/index.ts → No matches found
+- [x] tests/engines/vite-engine.spec.ts 삭제됨: `test -f` → DELETED
+
+### Scenario: 의존성 변경 �� lockfile 갱신
+- [x] pnpm install 성공: Packages: +1 -184, Done in 6.1s

package/tests/orchestrators/build-orchestrator.spec.ts

@@ -27,7 +27,7 @@ vi.mock("../../src/utils/copy-src", () => ({
   copySrcFiles: vi.fn().mockResolvedValue(undefined),
 }));
 
-vi.mock("../../src/utils/lint-utils", () => ({
+vi.mock("../../src/lint/lint-utils", () => ({
   runLintInWorker: vi.fn().mockResolvedValue({ success: true, errorCount: 0, warningCount: 0, formattedOutput: "" }),
 }));
 
@@ -37,7 +37,7 @@ vi.mock("../../src/utils/output-utils", () => ({
   ),
 }));
 
-vi.mock("../../src/utils/typecheck-serialization", () => ({
+vi.mock("../../src/typecheck/typecheck-serialization", () => ({
   deserializeDiagnostic: vi.fn((d: any) => d),
 }));
 
@@ -968,7 +968,7 @@ describe("BuildOrchestrator native build integration (Slice 1)", () => {
 
 //#region Slice 3: build 명령어 lint 통합 (Feature 3.2)
 
-const { runLintInWorker } = await import("../../src/utils/lint-utils");
+const { runLintInWorker } = await import("../../src/lint/lint-utils");
 
 describe("BuildOrchestrator lint integration", () => {
   // build에서 lint를 실행하지 않는다 (lint는 check에서만 실행)