@simplysm/sd-cli 13.0.100 → 14.0.1

package/tests/commands/typecheck.spec.ts

@@ -0,0 +1,294 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+//#region Mocks
+
+const mocks = vi.hoisted(() => ({
+  loadSdConfig: vi.fn(),
+  deserializeDiagnostic: vi.fn((d: any) => d),
+  typecheckNonPackageFiles: vi.fn(),
+  createBuildEngine: vi.fn(),
+}));
+
+const mockEngines: Array<{
+  run: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+}> = [];
+
+vi.mock("../../src/utils/sd-config", () => ({
+  loadSdConfig: mocks.loadSdConfig,
+}));
+
+vi.mock("../../src/utils/typecheck-serialization", () => ({
+  deserializeDiagnostic: mocks.deserializeDiagnostic,
+}));
+
+vi.mock("../../src/utils/typecheck-non-package", () => ({
+  typecheckNonPackageFiles: mocks.typecheckNonPackageFiles,
+}));
+
+vi.mock("../../src/engines/index", () => ({
+  createBuildEngine: mocks.createBuildEngine,
+}));
+
+vi.mock("typescript", async (importOriginal) => {
+  const orig = await importOriginal<Record<string, unknown>>();
+  const origDefault = (orig["default"] ?? orig) as Record<string, unknown>;
+  return {
+    ...orig,
+    default: {
+      ...origDefault,
+      sortAndDeduplicateDiagnostics: vi.fn((d: unknown[]) => d),
+      formatDiagnosticsWithColorAndContext: vi.fn(() => "formatted diagnostics"),
+    },
+  };
+});
+
+vi.mock("consola", () => {
+  const fns = (): Record<string, unknown> => ({
+    debug: vi.fn(), start: vi.fn(), success: vi.fn(),
+    info: vi.fn(), error: vi.fn(), warn: vi.fn(), log: vi.fn(),
+    withTag: vi.fn(() => fns()),
+    level: 0,
+  });
+  const c = fns();
+  return { consola: c, default: c, LogLevels: {} };
+});
+
+const { executeTypecheck } = await import("../../src/commands/typecheck");
+
+//#endregion
+
+//#region Helpers
+
+function createMockEngine() {
+  const engine = {
+    run: vi.fn().mockResolvedValue({
+      success: true,
+      js: { success: true, errors: [], warnings: [] },
+      dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+    }),
+    startWatch: vi.fn(),
+    stop: vi.fn().mockResolvedValue(undefined),
+  };
+  mockEngines.push(engine);
+  return engine;
+}
+
+function setupDefaults(packages: Record<string, any> = {}) {
+  mocks.loadSdConfig.mockResolvedValue({ packages });
+  mocks.createBuildEngine.mockImplementation(() => createMockEngine() as any);
+  mocks.typecheckNonPackageFiles.mockReturnValue({
+    success: true, errorCount: 0, warningCount: 0, diagnostics: [],
+  });
+}
+
+//#endregion
+
+//#region Tests
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockEngines.length = 0;
+});
+
+describe("executeTypecheck", () => {
+  it("uses BuildEngine.run({js:false, dts:false}) for library packages", async () => {
+    setupDefaults({
+      "core-common": { target: "neutral" },
+      "core-node": { target: "node" },
+    });
+
+    const result = await executeTypecheck({ targets: [], options: [] });
+
+    expect(result.success).toBe(true);
+    expect(mocks.createBuildEngine).toHaveBeenCalledTimes(2);
+    for (const engine of mockEngines) {
+      expect(engine.run).toHaveBeenCalledWith({ js: false, dts: false });
+      expect(engine.stop).toHaveBeenCalled();
+    }
+  });
+
+  it("uses BuildEngine.run({js:false, dts:false}) for server packages", async () => {
+    setupDefaults({
+      "demo-server": { target: "server" },
+    });
+
+    const result = await executeTypecheck({ targets: [], options: [] });
+
+    expect(result.success).toBe(true);
+    expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
+    expect(mocks.createBuildEngine).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: "demo-server",
+        config: expect.objectContaining({ target: "server" }),
+      }),
+      expect.any(Object),
+    );
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: false, dts: false });
+  });
+
+  it("excludes scripts packages from typecheck", async () => {
+    setupDefaults({
+      "core-common": { target: "neutral" },
+      "sd-claude": { target: "scripts" },
+    });
+
+    await executeTypecheck({ targets: [], options: [] });
+
+    // Only 1 engine created (for core-common), scripts excluded
+    expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
+    expect(mocks.createBuildEngine).toHaveBeenCalledWith(
+      expect.objectContaining({ name: "core-common" }),
+      expect.any(Object),
+    );
+  });
+
+  it("excludes client packages from typecheck (no engine yet)", async () => {
+    setupDefaults({
+      "core-common": { target: "neutral" },
+      "my-app": { target: "client", server: "demo-server" },
+    });
+
+    await executeTypecheck({ targets: [], options: [] });
+
+    expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
+  });
+
+  it("runs non-package typecheck when no targets specified", async () => {
+    setupDefaults({ "core-common": { target: "neutral" } });
+
+    await executeTypecheck({ targets: [], options: [] });
+
+    expect(mocks.typecheckNonPackageFiles).toHaveBeenCalledWith(process.cwd());
+  });
+
+  it("skips non-package typecheck when all targets are package paths", async () => {
+    setupDefaults({ "core-common": { target: "neutral" } });
+
+    await executeTypecheck({ targets: ["packages/core-common"], options: [] });
+
+    expect(mocks.typecheckNonPackageFiles).not.toHaveBeenCalled();
+  });
+
+  it("aggregates diagnostics from engines and non-package", async () => {
+    setupDefaults({ "core-common": { target: "neutral" } });
+
+    const engineDiag = { category: 1, code: 2322, messageText: "engine err" };
+    mocks.createBuildEngine.mockImplementation(() => {
+      const engine = {
+        run: vi.fn().mockResolvedValue({
+          success: false,
+          js: { success: true, errors: [], warnings: [] },
+          dts: { success: false, errors: [], warnings: [], diagnostics: [engineDiag] },
+        }),
+        startWatch: vi.fn(),
+        stop: vi.fn().mockResolvedValue(undefined),
+      };
+      mockEngines.push(engine);
+      return engine as any;
+    });
+
+    const nonPkgDiag = { category: 1, code: 2345, messageText: "non-pkg err" };
+    mocks.typecheckNonPackageFiles.mockReturnValue({
+      success: false, errorCount: 1, warningCount: 0, diagnostics: [nonPkgDiag],
+    });
+
+    const result = await executeTypecheck({ targets: [], options: [] });
+
+    expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
+    expect(mocks.typecheckNonPackageFiles).toHaveBeenCalled();
+
+    expect(result.success).toBe(false);
+    expect(result.errorCount).toBe(2);
+  });
+
+  it("limits concurrency of BuildEngine workers", async () => {
+    const packages: Record<string, any> = {};
+    for (let i = 0; i < 50; i++) {
+      packages[`pkg-${i}`] = { target: "neutral" };
+    }
+    setupDefaults(packages);
+
+    let active = 0;
+    let maxActive = 0;
+    mocks.createBuildEngine.mockImplementation(() => {
+      const engine = {
+        run: vi.fn(async () => {
+          active++;
+          maxActive = Math.max(maxActive, active);
+          await new Promise((resolve) => setTimeout(resolve, 5));
+          active--;
+          return {
+            success: true,
+            js: { success: true, errors: [], warnings: [] },
+            dts: { success: true, errors: [], warnings: [], diagnostics: [] },
+          };
+        }),
+        startWatch: vi.fn(),
+        stop: vi.fn().mockResolvedValue(undefined),
+      };
+      mockEngines.push(engine);
+      return engine as any;
+    });
+
+    await executeTypecheck({ targets: [], options: [] });
+
+    expect(maxActive).toBeLessThan(50);
+    expect(maxActive).toBeGreaterThan(0);
+  });
+
+  it("stops engine even when run fails", async () => {
+    setupDefaults({ "core-common": { target: "neutral" } });
+    mocks.createBuildEngine.mockImplementation(() => {
+      const engine = {
+        run: vi.fn().mockRejectedValue(new Error("build error")),
+        startWatch: vi.fn(),
+        stop: vi.fn().mockResolvedValue(undefined),
+      };
+      mockEngines.push(engine);
+      return engine as any;
+    });
+
+    const result = await executeTypecheck({ targets: [], options: [] });
+
+    expect(result.success).toBe(false);
+    expect(mockEngines[0].stop).toHaveBeenCalled();
+  });
+
+  it("passes options to loadSdConfig", async () => {
+    setupDefaults({});
+
+    await executeTypecheck({ targets: [], options: ["key=value"] });
+
+    expect(mocks.loadSdConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ options: ["key=value"] }),
+    );
+  });
+
+  it("filters packages by targets", async () => {
+    setupDefaults({
+      "core-common": { target: "neutral" },
+      "core-node": { target: "node" },
+    });
+
+    await executeTypecheck({ targets: ["packages/core-common"], options: [] });
+
+    // Only core-common should have an engine
+    expect(mocks.createBuildEngine).toHaveBeenCalledTimes(1);
+    expect(mocks.createBuildEngine).toHaveBeenCalledWith(
+      expect.objectContaining({ name: "core-common" }),
+      expect.any(Object),
+    );
+  });
+
+  it("returns success when no packages to typecheck", async () => {
+    setupDefaults({});
+
+    const result = await executeTypecheck({ targets: [], options: [] });
+
+    expect(result.success).toBe(true);
+    expect(mocks.createBuildEngine).not.toHaveBeenCalled();
+  });
+});
+
+//#endregion

package/tests/commands/watch.spec.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  initialize: vi.fn(async () => {}),
+  start: vi.fn(async () => {}),
+  awaitTermination: vi.fn(async () => {}),
+  shutdown: vi.fn(async () => {}),
+  ctor: vi.fn(),
+}));
+
+vi.mock("../../src/orchestrators/DevWatchOrchestrator", () => ({
+  DevWatchOrchestrator: vi.fn().mockImplementation(function (this: any, options: any) {
+    mocks.ctor(options);
+    this.initialize = mocks.initialize;
+    this.start = mocks.start;
+    this.awaitTermination = mocks.awaitTermination;
+    this.shutdown = mocks.shutdown;
+  }),
+}));
+
+const { runWatch } = await import("../../src/commands/watch");
+
+describe("runWatch", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.initialize.mockResolvedValue(undefined);
+    mocks.start.mockResolvedValue(undefined);
+    mocks.awaitTermination.mockResolvedValue(undefined);
+    mocks.shutdown.mockResolvedValue(undefined);
+  });
+
+  it("creates DevWatchOrchestrator with mode:watch and runs lifecycle", async () => {
+    await runWatch({ targets: ["core-common"], options: ["-o", "fast"] });
+
+    expect(mocks.ctor).toHaveBeenCalledWith({
+      mode: "watch",
+      targets: ["core-common"],
+      options: ["-o", "fast"],
+    });
+
+    expect(mocks.initialize).toHaveBeenCalledOnce();
+    expect(mocks.start).toHaveBeenCalledOnce();
+    expect(mocks.awaitTermination).toHaveBeenCalledOnce();
+    expect(mocks.shutdown).toHaveBeenCalledOnce();
+  });
+
+  it("calls shutdown even when initialize throws", async () => {
+    mocks.initialize.mockRejectedValueOnce(new Error("config error"));
+
+    await expect(runWatch({ targets: [], options: [] })).rejects.toThrow("config error");
+    expect(mocks.shutdown).toHaveBeenCalledOnce();
+  });
+});

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

@@ -0,0 +1,247 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("consola", () => ({
+  consola: {
+    withTag: vi.fn(() => ({
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    })),
+  },
+}));
+
+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 mockHasAngularCompilerOptions = vi.fn<(pkgDir: string) => boolean>();
+vi.mock("../../src/utils/tsconfig", () => ({
+  hasAngularCompilerOptions: (...args: [string]) => mockHasAngularCompilerOptions(...args),
+}));
+
+const { createBuildEngine } = 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");
+
+import type { BuildPackageInfo, ClientPackageInfo, ServerPackageInfo } from "../../src/engines/types";
+
+describe("createBuildEngine", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // Acceptance: Scenario "비-Angular Library 패키지"
+  it("returns TscEngine for node target package", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(false);
+    const pkg: BuildPackageInfo = {
+      name: "test",
+      dir: "/packages/test",
+      config: { target: "node" } as any,
+    };
+
+    const engine = createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(TscEngine);
+  });
+
+  it("returns TscEngine for browser target package", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(false);
+    const pkg: BuildPackageInfo = {
+      name: "test",
+      dir: "/packages/test",
+      config: { target: "browser" } as any,
+    };
+
+    const engine = createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(TscEngine);
+  });
+
+  it("returns TscEngine for neutral target package", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(false);
+    const pkg: BuildPackageInfo = {
+      name: "test",
+      dir: "/packages/test",
+      config: { target: "neutral" } as any,
+    };
+
+    const engine = createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(TscEngine);
+  });
+
+  // Acceptance: Scenario "Server 패키지는 변경 없음"
+  it("returns ServerEsbuildEngine for server target package", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(false);
+    const pkg: ServerPackageInfo = {
+      name: "test-server",
+      dir: "/packages/test-server",
+      config: { target: "server" } as any,
+    };
+
+    const engine = createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(ServerEsbuildEngine);
+  });
+
+  // Acceptance: Scenario "Angular Library 패키지는 변경 없음"
+  it("returns NgtscEngine when tsconfig has angularCompilerOptions", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(true);
+    const pkg: BuildPackageInfo = {
+      name: "angular",
+      dir: "/packages/angular",
+      config: { target: "browser" } as any,
+    };
+
+    const engine = createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(NgtscEngine);
+  });
+
+  it("returns TscEngine when tsconfig has no angularCompilerOptions", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(false);
+    const pkg: BuildPackageInfo = {
+      name: "core-browser",
+      dir: "/packages/core-browser",
+      config: { target: "browser" } as any,
+    };
+
+    const engine = createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(TscEngine);
+  });
+
+  // Unit: hasAngularCompilerOptions is called with the package directory
+  it("calls hasAngularCompilerOptions with the package dir for library targets", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(false);
+    const pkg: BuildPackageInfo = {
+      name: "test",
+      dir: "/packages/test",
+      config: { target: "browser" } as any,
+    };
+
+    createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(mockHasAngularCompilerOptions).toHaveBeenCalledWith("/packages/test");
+  });
+
+  // Unit: does not call hasAngularCompilerOptions for server targets
+  it("does not check angularCompilerOptions for server target", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(false);
+    const pkg: ServerPackageInfo = {
+      name: "test-server",
+      dir: "/packages/test-server",
+      config: { target: "server" } as any,
+    };
+
+    createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(mockHasAngularCompilerOptions).not.toHaveBeenCalled();
+  });
+
+  // Acceptance: Scenario "client target에 ViteEngine 생성"
+  it("returns ViteEngine for client target package", () => {
+    const pkg: ClientPackageInfo = {
+      name: "my-client",
+      dir: "/packages/my-client",
+      config: { target: "client", server: "my-server" } as any,
+    };
+
+    const engine = createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(engine).toBeInstanceOf(ViteEngine);
+  });
+
+  // Unit: does not call hasAngularCompilerOptions for client targets
+  it("does not check angularCompilerOptions for client target", () => {
+    mockHasAngularCompilerOptions.mockReturnValue(false);
+    const pkg: ClientPackageInfo = {
+      name: "my-client",
+      dir: "/packages/my-client",
+      config: { target: "client", server: "my-server" } as any,
+    };
+
+    createBuildEngine(pkg, { cwd: "/root" });
+
+    expect(mockHasAngularCompilerOptions).not.toHaveBeenCalled();
+  });
+});
+
+// Acceptance: Scenario "ViteEngine이 어댑터 격리를 준수한다"
+describe("ViteEngine adapter isolation", () => {
+  it("ViteEngine and its worker do not directly import @angular/* packages", async () => {
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+
+    const sdCliSrc = path.resolve(import.meta.dirname, "../../src");
+
+    const filesToCheck = [
+      path.join(sdCliSrc, "engines", "ViteEngine.ts"),
+      path.join(sdCliSrc, "workers", "vite-build.worker.ts"),
+    ];
+
+    const angularImportPattern = /from\s+["']@angular\/(build|compiler-cli)/;
+
+    for (const filePath of filesToCheck) {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const hasDirectImport = angularImportPattern.test(content);
+      expect(hasDirectImport, `${path.basename(filePath)} should not directly import @angular/*`).toBe(false);
+    }
+  });
+
+  it("vite-build.worker.ts imports Angular APIs through angular-build.ts adapter", async () => {
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+
+    const workerFile = path.resolve(import.meta.dirname, "../../src/workers/vite-build.worker.ts");
+    const content = fs.readFileSync(workerFile, "utf-8");
+
+    const angularImportPattern = /from\s+["']@angular\/(build|compiler-cli)/;
+    expect(angularImportPattern.test(content)).toBe(false);
+  });
+});
+
+// Acceptance: Scenario "NgtscEngine이 어댑터 격리를 준수한다"
+describe("NgtscEngine adapter isolation", () => {
+  it("NgtscEngine and its dependencies do not directly import @angular/* packages", async () => {
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+
+    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, "utils", "output-path-rewriter.ts"),
+    ];
+
+    const angularImportPattern = /from\s+["']@angular\/(build|compiler-cli)/;
+
+    for (const filePath of filesToCheck) {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const hasDirectImport = angularImportPattern.test(content);
+      expect(hasDirectImport, `${path.basename(filePath)} should not directly import @angular/*`).toBe(false);
+    }
+  });
+
+  it("all Angular API access goes through angular-build.ts adapter", async () => {
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+
+    const ngtscBuildCore = path.resolve(import.meta.dirname, "../../src/utils/ngtsc-build-core.ts");
+    const content = fs.readFileSync(ngtscBuildCore, "utf-8");
+
+    expect(content).toContain("./angular-build");
+  });
+});