@simplysm/sd-cli 14.0.29 → 14.0.32

package/tests/engines/base-engine.spec.ts

@@ -22,7 +22,7 @@ const { TscEngine } = await import("../../src/engines/TscEngine");
 const { BaseEngine } = await import("../../src/engines/BaseEngine");
 
 import type { BuildPackageInfo, BuildOutput } from "../../src/engines/types";
-import type { BuildResult } from "../../src/infra/ResultCollector";
+import type { BuildResult } from "../../src/runtime/ResultCollector";
 
 // --- Helpers ---
 
@@ -62,6 +62,24 @@ describe("BaseEngine", () => {
     expect(TscEngine.prototype.hasOwnProperty("stop")).toBe(false);
   });
 
+  describe("_createWorker resourceLimits", () => {
+    it("Worker.create에 resourceLimits를 전달한다", async () => {
+      const { Worker } = await import("@simplysm/core-node");
+
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.run({ js: true, dts: true });
+
+      expect(Worker.create).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          resourceLimits: { maxOldGenerationSizeMb: 8192 },
+        }),
+      );
+
+      await engine.stop();
+    });
+  });
+
   describe("shared stop() behavior", () => {
     it("calls stopWatch and terminate in watch mode", async () => {
       mockWorker.startWatch.mockImplementation(() => {
@@ -300,6 +318,44 @@ describe("BaseEngine", () => {
     });
   });
 
+  describe("_normalizeResult", () => {
+    it("errors/warnings가 undefined이면 빈 배열로 정규화한다", async () => {
+      mockWorker.build.mockResolvedValue({
+        build: { success: true, errors: undefined, warnings: undefined, diagnostics: [{ code: 1 }] },
+        lint: { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" },
+      });
+
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: true });
+
+      expect(result.build.errors).toEqual([]);
+      expect(result.build.warnings).toEqual([]);
+      expect(result.build.success).toBe(true);
+      expect(result.build.diagnostics).toEqual([{ code: 1 }]);
+      expect(result.lint).toEqual({ success: true, errorCount: 0, warningCount: 0, formattedOutput: "" });
+
+      await engine.stop();
+    });
+
+    it("errors/warnings가 존재하면 그대로 전달한다", async () => {
+      mockWorker.build.mockResolvedValue({
+        build: { success: false, errors: ["err1"], warnings: ["warn1"], diagnostics: [{ code: 2322 }] },
+        lint: undefined,
+      });
+
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: true });
+
+      expect(result.build.errors).toEqual(["err1"]);
+      expect(result.build.warnings).toEqual(["warn1"]);
+      expect(result.build.success).toBe(false);
+      expect(result.build.diagnostics).toEqual([{ code: 2322 }]);
+      expect(result.lint).toBeUndefined();
+
+      await engine.stop();
+    });
+  });
+
   describe("lint 통합", () => {
     describe("BuildOutput.lint flag controls lint execution", () => {
       it("BuildOutput이 lint 불리언 플래그를 수용", () => {
@@ -357,10 +413,10 @@ describe("BaseEngine", () => {
         const mockResultCollector = { add: vi.fn() };
 
         mockWorker.startWatch.mockImplementation(() => {
-          const buildHandler = mockWorker.on.mock.calls.find(
-            (call: any[]) => call[0] === "build",
-          )?.[1];
-          buildHandler?.({
+          const buildHandlers = mockWorker.on.mock.calls
+            .filter((call: any[]) => call[0] === "build")
+            .map((call: any[]) => call[1]);
+          const buildData = {
             build: { success: true },
             lint: {
               success: false,
@@ -368,7 +424,10 @@ describe("BaseEngine", () => {
               warningCount: 0,
               formattedOutput: "errors",
             },
-          });
+          };
+          for (const handler of buildHandlers) {
+            handler(buildData);
+          }
         });
 
         const engine = new TscEngine({

package/tests/engines/engine-adapter-isolation.spec.ts

@@ -1,17 +1,16 @@
 import { describe, it, expect } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
 
-// Acceptance: Scenario "ViteEngine이 어댑터 격리를 준수한다"
-describe("ViteEngine adapter isolation", () => {
-  it("ViteEngine과 그 워커가 @angular/* 패키지를 직접 import하지 않음", async () => {
-    const fs = await import("node:fs");
-    const path = await import("node:path");
+// Acceptance: Scenario "EsbuildClientEngine이 어댑터 격리를 준수한다"
+describe("EsbuildClientEngine adapter isolation", () => {
+  it("EsbuildClientEngine과 그 워커가 @angular/* 패키지를 직접 import하지 않음", () => {
 
     const sdCliSrc = path.resolve(import.meta.dirname, "../../src");
 
     const filesToCheck = [
-      path.join(sdCliSrc, "engines", "ViteEngine.ts"),
+      path.join(sdCliSrc, "engines", "EsbuildClientEngine.ts"),
       path.join(sdCliSrc, "workers", "client.worker.ts"),
-      path.join(sdCliSrc, "utils", "vite-config.ts"),
     ];
 
     const angularImportPattern = /from\s+["']@angular\/(build|compiler-cli)/;
@@ -26,9 +25,7 @@ describe("ViteEngine adapter isolation", () => {
     }
   });
 
-  it("vite-angular-plugin.ts imports only JavaScriptTransformer from @angular/build/private", async () => {
-    const fs = await import("node:fs");
-    const path = await import("node:path");
+  it("vite-angular-plugin.ts imports only JavaScriptTransformer from @angular/build/private", () => {
 
     const pluginFile = path.resolve(
       import.meta.dirname,
@@ -46,16 +43,14 @@ describe("ViteEngine adapter isolation", () => {
 
 // Acceptance: Scenario "NgtscEngine이 어댑터 격리를 준수한다"
 describe("NgtscEngine adapter isolation", () => {
-  it("NgtscEngine과 그 의존성이 @angular/* 패키지를 직접 import하지 않음", async () => {
-    const fs = await import("node:fs");
-    const path = await import("node:path");
+  it("NgtscEngine과 그 의존성이 @angular/* 패키지를 직접 import하지 않음", () => {
 
     const sdCliSrc = path.resolve(import.meta.dirname, "../../src");
 
     const filesToCheck = [
       path.join(sdCliSrc, "engines", "NgtscEngine.ts"),
       path.join(sdCliSrc, "workers", "ngtsc-build.worker.ts"),
-      path.join(sdCliSrc, "utils", "ngtsc-build-core.ts"),
+      path.join(sdCliSrc, "angular", "ngtsc-build-core.ts"),
       path.join(sdCliSrc, "utils", "output-path-rewriter.ts"),
     ];
 
@@ -71,14 +66,12 @@ describe("NgtscEngine adapter isolation", () => {
     }
   });
 
-  it("all Angular API access goes through angular-compiler.ts adapter", async () => {
-    const fs = await import("node:fs");
-    const path = await import("node:path");
+  it("all Angular API access goes through angular-compiler.ts adapter", () => {
 
     // Angular API 접근은 angular-build-pipeline.ts를 통해 angular-compiler.ts로 이루어진다
     const buildPipeline = path.resolve(
       import.meta.dirname,
-      "../../src/utils/angular-build-pipeline.ts",
+      "../../src/angular/angular-build-pipeline.ts",
     );
     const content = fs.readFileSync(buildPipeline, "utf-8");
 

package/tests/engines/engine-selection.spec.ts

@@ -13,11 +13,11 @@ vi.mock("@simplysm/core-node", () => ({
   },
 }));
 
-const { createBuildEngine } = await import("../../src/engines/index");
+const { createBuildEngine, createTypecheckEngine } = await import("../../src/engines/index");
 const { TscEngine } = await import("../../src/engines/TscEngine");
 const { NgtscEngine } = await import("../../src/engines/NgtscEngine");
 const { ServerEsbuildEngine } = await import("../../src/engines/ServerEsbuildEngine");
-const { ViteEngine } = await import("../../src/engines/ViteEngine");
+const { EsbuildClientEngine } = await import("../../src/engines/EsbuildClientEngine");
 
 import type { BuildPackageInfo, ClientPackageInfo, ServerPackageInfo } from "../../src/engines/types";
 
@@ -103,8 +103,8 @@ describe("createBuildEngine", () => {
     expect(engine).toBeInstanceOf(TscEngine);
   });
 
-  // Acceptance: Scenario "client target에 ViteEngine 생성"
-  it("returns ViteEngine for client target package", () => {
+  // Acceptance: Scenario "client target에 EsbuildClientEngine 생성"
+  it("returns EsbuildClientEngine for client target package", () => {
     const pkg: ClientPackageInfo = {
       name: "my-client",
       dir: "/packages/my-client",
@@ -113,7 +113,40 @@ describe("createBuildEngine", () => {
 
     const engine = createBuildEngine(pkg, { cwd: "/root" });
 
-    expect(engine).toBeInstanceOf(ViteEngine);
+    expect(engine).toBeInstanceOf(EsbuildClientEngine);
   });
 
 });
+
+describe("createTypecheckEngine", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(packageUtils, "hasAngularCoreDependency").mockReturnValue(false);
+  });
+
+  // Unit: client target은 EsbuildClientEngine이 아닌 엔진이 반환
+  it("does not return EsbuildClientEngine for client target", () => {
+    const pkg: ClientPackageInfo = {
+      name: "my-client",
+      dir: "/packages/my-client",
+      config: { target: "client", server: "my-server" } as any,
+    };
+
+    const engine = createTypecheckEngine(pkg, { cwd: "/root" });
+
+    expect(engine).not.toBeInstanceOf(EsbuildClientEngine);
+  });
+
+  // Unit: neutral target은 TscEngine으로 위임
+  it("returns TscEngine for neutral target", () => {
+    const pkg: BuildPackageInfo = {
+      name: "core-common",
+      dir: "/packages/core-common",
+      config: { target: "neutral" } as any,
+    };
+
+    const engine = createTypecheckEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(TscEngine);
+  });
+});

package/tests/engines/engine-typecheck-selection.acc.spec.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as packageUtils from "../../src/utils/package-utils";
+
+vi.mock("@simplysm/core-node", () => ({
+  Worker: {
+    create: vi.fn(() => ({
+      build: vi.fn(),
+      startWatch: vi.fn(),
+      stopWatch: vi.fn(),
+      terminate: vi.fn(),
+      on: vi.fn(),
+    })),
+  },
+}));
+
+const { createTypecheckEngine } = await import("../../src/engines/index");
+const { TscEngine } = await import("../../src/engines/TscEngine");
+const { NgtscEngine } = await import("../../src/engines/NgtscEngine");
+const { ServerEsbuildEngine } = await import("../../src/engines/ServerEsbuildEngine");
+
+import type {
+  BuildPackageInfo,
+  ClientPackageInfo,
+  ServerPackageInfo,
+} from "../../src/engines/types";
+
+describe("createTypecheckEngine", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(packageUtils, "hasAngularCoreDependency").mockReturnValue(false);
+  });
+
+  // Acceptance: Scenario "client target + typecheck + Angular 의존성 있음"
+  it("returns NgtscEngine for client target when @angular/core dependency exists", () => {
+    vi.mocked(packageUtils.hasAngularCoreDependency).mockReturnValue(true);
+    const pkg: ClientPackageInfo = {
+      name: "my-client",
+      dir: "/packages/my-client",
+      config: { target: "client", server: "my-server" } as any,
+    };
+
+    const engine = createTypecheckEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(NgtscEngine);
+  });
+
+  // Acceptance: Scenario "client target + typecheck + Angular 의존성 없음"
+  it("returns TscEngine for client target when no @angular/core dependency", () => {
+    const pkg: ClientPackageInfo = {
+      name: "my-client",
+      dir: "/packages/my-client",
+      config: { target: "client", server: "my-server" } as any,
+    };
+
+    const engine = createTypecheckEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(TscEngine);
+  });
+
+  // Acceptance: Scenario "server target은 변경 없음"
+  it("returns ServerEsbuildEngine for server target (delegates to createBuildEngine)", () => {
+    const pkg: ServerPackageInfo = {
+      name: "test-server",
+      dir: "/packages/test-server",
+      config: { target: "server" } as any,
+    };
+
+    const engine = createTypecheckEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(ServerEsbuildEngine);
+  });
+
+  // Acceptance: Scenario "browser target은 변경 없음"
+  it("returns TscEngine for browser target (delegates to createBuildEngine)", () => {
+    const pkg: BuildPackageInfo = {
+      name: "core-browser",
+      dir: "/packages/core-browser",
+      config: { target: "browser" } as any,
+    };
+
+    const engine = createTypecheckEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(TscEngine);
+  });
+});

package/tests/engines/engine-typecheck-selection.verify.md

@@ -0,0 +1,8 @@
+# TypecheckOrchestrator 원본 config 전달 — LLM 검증
+
+## 검증 항목
+
+- [x] target 변환 로직 제거됨: `TypecheckOrchestrator.ts:133-142`에서 `config.target === "client" ? { target: "browser" as const } : config` 코드가 제거되고, 원본 `config`가 그대로 `_typecheckTasks`에 저장됨
+- [x] createTypecheckEngine 호출: `TypecheckOrchestrator.ts:209`에서 `createBuildEngine` 대신 `createTypecheckEngine`을 호출함
+- [x] import 변경: `TypecheckOrchestrator.ts:7`에서 `createBuildEngine` 대신 `createTypecheckEngine`을 import함
+- [x] createTypecheckEngine 내부 변환: `engines/index.ts`의 `createTypecheckEngine`이 client target을 `{ target: "browser" }`로 변환하여 `createBuildEngine`에 위임함

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

@@ -0,0 +1,161 @@
+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 for .dev-port deletion in stop()
+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 Acceptance", () => {
+  // Scenario: 프로덕션 빌드 실행
+  it("프로덕션 빌드를 실행하고 EngineResult를 반환한다", async () => {
+    // Given: client 패키지가 정의되어 있다
+    mockWorker.build.mockResolvedValue({ success: true });
+
+    const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+
+    // When: run()을 호출한다
+    const result = await engine.run({ js: true, dts: false });
+
+    // Then: EngineResult에 성공 여부가 반환된다
+    expect(result.build.success).toBe(true);
+    expect(result.build.errors).toEqual([]);
+    expect(result.build.diagnostics).toEqual([]);
+
+    await engine.stop();
+  });
+
+  // Scenario: dev watch 모드 시작
+  it("dev watch를 시작하고 serverReady로 포트를 전달받는다", async () => {
+    // Given: client 패키지가 정의되어 있다
+    mockWorker.startWatch.mockImplementation(() => {
+      const serverReadyHandler = mockWorker.on.mock.calls.find(
+        (call: any[]) => call[0] === "serverReady",
+      )?.[1];
+      serverReadyHandler?.({ port: 4200 });
+      return Promise.resolve({ success: true });
+    });
+
+    const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
+
+    // When: startWatch()를 호출한다
+    await engine.startWatch({ js: true, dts: false });
+
+    // Then: serverReady 이벤트로 포트 번호가 전달된다
+    expect(engine.port).toBe(4200);
+
+    await engine.stop();
+  });
+
+  // Scenario: dev watch 중 파일 변경
+  it("dev watch 중 빌드 이벤트를 ResultCollector에 보고한다", async () => {
+    // Given: dev watch 모드가 실행 중이다
+    const mockResultCollector = { add: vi.fn() };
+    const mockResolver = vi.fn();
+    const mockRebuildManager = { registerBuild: vi.fn(() => mockResolver) };
+
+    mockWorker.startWatch.mockResolvedValue({ success: true });
+
+    const engine = new EsbuildClientEngine({
+      cwd: "/root",
+      pkg: createMockPkg(),
+      resultCollector: mockResultCollector as any,
+      rebuildManager: mockRebuildManager as any,
+    });
+
+    await engine.startWatch({ js: true, dts: false });
+
+    // When: buildStart + build 이벤트가 발생한다
+    const buildStartHandler = mockWorker.on.mock.calls.find(
+      (call: any[]) => call[0] === "buildStart",
+    )?.[1];
+    const buildHandler = mockWorker.on.mock.calls.find(
+      (call: any[]) => call[0] === "build",
+    )?.[1];
+
+    buildStartHandler?.({});
+    buildHandler?.({ success: true });
+
+    // Then: ResultCollector에 결과가 추가된다
+    const buildResult = mockResultCollector.add.mock.calls.find(
+      (c: any[]) => c[0].type === "build",
+    );
+    expect(buildResult).toBeDefined();
+    expect(buildResult![0].status).toBe("success");
+
+    // And: RebuildManager의 resolver가 호출된다
+    expect(mockRebuildManager.registerBuild).toHaveBeenCalled();
+    expect(mockResolver).toHaveBeenCalled();
+
+    await engine.stop();
+  });
+
+  // Scenario: 엔진 중지
+  it("stop()으로 worker를 종료하고 .dev-port를 삭제한다", async () => {
+    // Given: dev watch 모드가 실행 중이다
+    mockWorker.startWatch.mockResolvedValue({ success: true });
+
+    const engine = new EsbuildClientEngine({
+      cwd: "/root",
+      pkg: createMockPkg({ dir: "/packages/my-client" }),
+    });
+
+    await engine.startWatch({ js: true, dts: false });
+
+    // When: stop()이 호출된다
+    await engine.stop();
+
+    // Then: worker가 종료된다
+    expect(mockWorker.stopWatch).toHaveBeenCalled();
+    expect(mockWorker.terminate).toHaveBeenCalled();
+
+    // And: .dev-port 파일 삭제가 시도된다
+    expect(mockUnlinkSync).toHaveBeenCalledWith(
+      expect.stringContaining(".dev-port"),
+    );
+  });
+});