@simplysm/sd-cli 14.0.42 → 14.0.44

package/tests/workers/library-build-worker.spec.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import path from "path";
-import * as tscBuild from "../../src/utils/tsc-build";
 import * as collectDepsModule from "../../src/deps/replace-deps/collect-deps";
 
 //#region Mocks
@@ -12,6 +11,35 @@ let mockSend: ReturnType<typeof vi.fn>;
 const mockOnChange = vi.fn();
 const mockWatcherClose = vi.fn();
 
+// SdTsCompiler mock
+const { mockCompileAsync, MockSdTsCompiler, mockSideEffectScssRegistry } = vi.hoisted(() => {
+  const compileAsync = vi.fn();
+  const sideEffectScssRegistry = new Map();
+  const Compiler = vi.fn().mockImplementation(function (this: any) {
+    this.compileAsync = compileAsync;
+    this.sideEffectScssRegistry = sideEffectScssRegistry;
+  });
+  return { mockCompileAsync: compileAsync, MockSdTsCompiler: Compiler, mockSideEffectScssRegistry: sideEffectScssRegistry };
+});
+
+vi.mock("../../src/ts-compiler/SdTsCompiler", () => ({
+  SdTsCompiler: MockSdTsCompiler,
+}));
+
+// ngtsc-build-core mock (writeEmitResults + compileSideEffectScss)
+const { mockWriteEmitResults, mockCompileSideEffectScss } = vi.hoisted(() => {
+  return { mockWriteEmitResults: vi.fn(), mockCompileSideEffectScss: vi.fn() };
+});
+
+vi.mock("../../src/angular/ngtsc-build-core", async (importOriginal) => {
+  const original = await importOriginal<typeof import("../../src/angular/ngtsc-build-core")>();
+  return {
+    ...original,
+    writeEmitResults: mockWriteEmitResults,
+    compileSideEffectScss: mockCompileSideEffectScss,
+  };
+});
+
 vi.mock("@simplysm/core-node", () => ({
   createWorker: vi.fn((fns: Record<string, Function>) => {
     workerFns = fns as any;
@@ -39,18 +67,6 @@ vi.mock("../../src/workers/shared-worker-lifecycle", () => ({
   })),
 }));
 
-// tsc build spy
-const mockRunTscPackageBuild = vi.spyOn(tscBuild, "runTscPackageBuild").mockReturnValue({
-  success: true,
-  errors: undefined,
-  diagnostics: [],
-  errorCount: 0,
-  warningCount: 0,
-  program: {
-    getSourceFiles: () => [{ fileName: "/pkg/src/index.ts" }],
-  },
-} as any);
-
 // collect-deps spy
 const mockCollectDeps = vi.spyOn(collectDepsModule, "collectDeps").mockReturnValue({
   workspaceDeps: [],
@@ -59,27 +75,33 @@ const mockCollectDeps = vi.spyOn(collectDepsModule, "collectDeps").mockReturnVal
 
 //#endregion
 
+const defaultCompileResult = {
+  program: { getSourceFiles: () => [{ fileName: "/pkg/src/index.ts" }] },
+  builderProgram: {},
+  isForAngular: false,
+  affectedFiles: new Set<string>(),
+  diagnostics: [] as any[],
+  errorCount: 0,
+  warningCount: 0,
+  errors: undefined as string[] | undefined,
+  emitResults: undefined,
+  lint: undefined,
+  scssErrors: [] as string[],
+  scssDependencies: new Map<string, Set<string>>(),
+};
+
 // Import triggers createWorker, capturing the functions
 await import("../../src/workers/library-build.worker");
 
 beforeEach(() => {
   vi.clearAllMocks();
-  mockRunTscPackageBuild.mockReturnValue({
-    success: true,
-    errors: undefined,
-    diagnostics: [],
-    errorCount: 0,
-    warningCount: 0,
-    program: {
-      getSourceFiles: () => [{ fileName: "/pkg/src/index.ts" }],
-    },
-  } as any);
+  mockCompileAsync.mockResolvedValue({ ...defaultCompileResult });
   mockCollectDeps.mockReturnValue({ workspaceDeps: [], replaceDeps: [] });
+  mockSideEffectScssRegistry.clear();
 });
 
 const buildInfo = {
   name: "test-pkg",
-  config: { target: "node" as const },
   cwd: "/",
   pkgDir: "/pkg",
   output: { js: true, dts: true },
@@ -109,16 +131,13 @@ describe("library-build.worker build()", () => {
 
   // Unit: tsc failure reflects in build result
   it("reports failure in build when tsc fails", async () => {
-    mockRunTscPackageBuild.mockReturnValueOnce({
-      success: false,
-      errors: ["TS2345: type error"],
-      diagnostics: [{ code: 2345, category: 1 }],
+    mockCompileAsync.mockResolvedValueOnce({
+      ...defaultCompileResult,
       errorCount: 1,
       warningCount: 0,
-      program: {
-        getSourceFiles: () => [{ fileName: "/pkg/src/index.ts" }],
-      },
-    } as any);
+      errors: ["TS2345: type error"],
+      diagnostics: [{ code: 2345, category: 1 }],
+    });
 
     const result = await workerFns["build"]({ ...buildInfo, output: { js: true, dts: true } });
 
@@ -129,6 +148,119 @@ describe("library-build.worker build()", () => {
 
 });
 
+const angularBuildInfo = {
+  name: "test-angular-lib",
+  cwd: "/workspace",
+  pkgDir: "/workspace/packages/test-angular-lib",
+  output: { js: true, dts: true, globalScss: true },
+};
+
+const angularCompileResult = {
+  ...defaultCompileResult,
+  program: { getSourceFiles: () => [{ fileName: "/workspace/packages/test-angular-lib/src/index.ts" }] },
+  isForAngular: true,
+  emitResults: [
+    { filename: "/workspace/packages/test-angular-lib/dist/index.js", contents: "export {};", sourceFileName: "/workspace/packages/test-angular-lib/src/index.ts" },
+  ],
+};
+
+describe("library-build.worker build() — Angular", () => {
+  // Acceptance: Angular one-shot build — writeEmitResults 호출
+  it("calls writeEmitResults with emitResults filtered to src/", async () => {
+    mockCompileAsync.mockResolvedValueOnce({
+      ...angularCompileResult,
+      emitResults: [
+        { filename: "dist/src-file.js", contents: "a", sourceFileName: "/workspace/packages/test-angular-lib/src/src-file.ts" },
+        { filename: "dist/ext.js", contents: "b", sourceFileName: "/workspace/packages/test-angular-lib/node_modules/ext.ts" },
+      ],
+    });
+
+    await workerFns["build"](angularBuildInfo);
+
+    expect(mockWriteEmitResults).toHaveBeenCalledTimes(1);
+    const emitArg = mockWriteEmitResults.mock.calls[0][0] as any[];
+    // src/ 하위만 필터됨
+    expect(emitArg).toHaveLength(1);
+    expect(emitArg[0].sourceFileName).toContain("src/src-file.ts");
+    // pkgDir 전달
+    expect(mockWriteEmitResults.mock.calls[0][1]).toBe(angularBuildInfo.pkgDir);
+    // Angular build 모드에서 scss 옵션 전달
+    expect(mockWriteEmitResults.mock.calls[0][2]).toEqual({
+      loadPaths: [
+        path.join(angularBuildInfo.pkgDir, "scss"),
+        path.join(angularBuildInfo.cwd, "node_modules"),
+      ],
+      scssErrors: [],
+      scssDependencies: expect.any(Map),
+      registry: expect.any(Map),
+      registryReverseIndex: expect.any(Map),
+      sideEffectScssDeps: expect.any(Map),
+    });
+  });
+
+  // Acceptance: Angular build with SCSS errors
+  it("returns success=false when scssErrors exist", async () => {
+    mockCompileAsync.mockResolvedValueOnce({
+      ...angularCompileResult,
+      scssErrors: ["SCSS error in styles.scss: variable not found"],
+    });
+
+    const result = await workerFns["build"](angularBuildInfo);
+
+    expect(result.build.success).toBe(false);
+    expect(result.build.errors).toContain("SCSS error in styles.scss: variable not found");
+  });
+
+  // Unit: ts errors + scss errors 병합
+  it("merges both ts errors and scss errors into build.errors", async () => {
+    mockCompileAsync.mockResolvedValueOnce({
+      ...angularCompileResult,
+      errorCount: 1,
+      errors: ["TS2345: type error"],
+      scssErrors: ["SCSS error"],
+    });
+
+    const result = await workerFns["build"](angularBuildInfo);
+
+    expect(result.build.success).toBe(false);
+    expect(result.build.errors).toEqual(["TS2345: type error", "SCSS error"]);
+  });
+
+  // Acceptance: Angular build 예외 처리
+  it("catches exceptions and returns error result", async () => {
+    mockCompileAsync.mockRejectedValueOnce(new Error("Fatal crash"));
+
+    const result = await workerFns["build"](angularBuildInfo);
+
+    expect(result.build.success).toBe(false);
+    expect(result.build.errors).toContain("Fatal crash");
+    expect(result.build.diagnostics).toEqual([]);
+  });
+
+  // Unit: emitResults가 undefined이면 writeEmitResults 미호출
+  it("skips writeEmitResults when emitResults is undefined", async () => {
+    mockCompileAsync.mockResolvedValueOnce({
+      ...angularCompileResult,
+      emitResults: undefined,
+    });
+
+    await workerFns["build"](angularBuildInfo);
+
+    expect(mockWriteEmitResults).not.toHaveBeenCalled();
+  });
+
+  // Unit: globalScss 옵션이 SdTsCompiler에 전달됨
+  it("passes globalScss to SdTsCompiler", async () => {
+    mockCompileAsync.mockResolvedValueOnce({ ...angularCompileResult });
+
+    await workerFns["build"](angularBuildInfo);
+
+    expect(MockSdTsCompiler).toHaveBeenCalledWith(expect.objectContaining({
+      globalScss: true,
+    }));
+  });
+});
+
 describe("library-build.worker startWatch()", () => {
   // Acceptance: Initial build completes before returning
   it("completes initial build and sends build event", async () => {
@@ -172,7 +304,7 @@ describe("library-build.worker startWatch()", () => {
   it("sends error event on rebuild exception", async () => {
     await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
 
-    mockRunTscPackageBuild.mockImplementationOnce(() => { throw new Error("tsc crash"); });
+    mockCompileAsync.mockRejectedValueOnce(new Error("tsc crash"));
     const onChangeCallback = mockOnChange.mock.calls[0][1];
     mockSend.mockClear();
 
@@ -219,14 +351,10 @@ describe("library-build.worker startWatch() dependency filter", () => {
   });
 
   const buildInfoWithProgram = () => {
-    mockRunTscPackageBuild.mockReturnValue({
-      success: true,
-      errors: undefined,
-      diagnostics: [],
-      errorCount: 0,
-      warningCount: 0,
+    mockCompileAsync.mockResolvedValue({
+      ...defaultCompileResult,
       program: createMockProgram(["/pkg/src/index.ts", "/pkg/src/utils.ts"]),
-    } as any);
+    });
   };
 
   // Acceptance: Skip rebuild when changed file is not in program
@@ -296,6 +424,136 @@ describe("library-build.worker startWatch() dependency filter", () => {
   });
 });
 
+describe("library-build.worker startWatch() — Angular", () => {
+  const angularWatchInfo = {
+    ...angularBuildInfo,
+    replaceDeps: undefined as Record<string, string> | undefined,
+  };
+
+  const angularWatchCompileResult = {
+    ...angularCompileResult,
+    program: {
+      getSourceFiles: () => [
+        { fileName: "/workspace/packages/test-angular-lib/src/index.ts" },
+        { fileName: "/workspace/packages/test-angular-lib/src/comp.ts" },
+      ],
+    },
+    scssDependencies: new Map<string, ReadonlySet<string>>(),
+  };
+
+  // Acceptance: Angular 초기 빌드 with SCSS globs
+  it("starts FsWatcher with scss globs when globalScss is true", async () => {
+    mockCompileAsync.mockResolvedValue({ ...angularWatchCompileResult });
+
+    await workerFns["startWatch"](angularWatchInfo);
+
+    const { FsWatcher } = await import("@simplysm/core-node");
+    const watchPaths = vi.mocked(FsWatcher.watch).mock.calls[0][0];
+    // src/**/*.{ts,scss,css} + scss/**/*.{scss,css}
+    expect(watchPaths.length).toBeGreaterThanOrEqual(2);
+    expect(watchPaths.some((p: string) => p.includes("*.{ts,scss,css}"))).toBe(true);
+    expect(watchPaths.some((p: string) => p.includes("*.{scss,css}"))).toBe(true);
+  });
+
+  // Acceptance: Angular 초기 빌드 — writeEmitResults with scss option
+  it("calls writeEmitResults with scss option in initial watch build", async () => {
+    mockCompileAsync.mockResolvedValue({ ...angularWatchCompileResult });
+
+    await workerFns["startWatch"](angularWatchInfo);
+
+    expect(mockWriteEmitResults).toHaveBeenCalledWith(
+      expect.any(Array),
+      angularWatchInfo.pkgDir,
+      expect.objectContaining({
+        loadPaths: expect.any(Array),
+        scssErrors: expect.any(Array),
+        scssDependencies: expect.any(Map),
+        registry: mockSideEffectScssRegistry,
+      }),
+    );
+  });
+
+  // Acceptance: globalScss가 SdTsCompiler에 전달됨
+  it("passes globalScss to SdTsCompiler in watch mode", async () => {
+    mockCompileAsync.mockResolvedValue({ ...angularWatchCompileResult });
+
+    await workerFns["startWatch"](angularWatchInfo);
+
+    expect(MockSdTsCompiler).toHaveBeenCalledWith(expect.objectContaining({
+      globalScss: true,
+    }));
+  });
+
+  // Acceptance: SCSS 의존성 역방향 탐색
+  it("adds SCSS-dependent files to modifiedFiles via combinedScssDeps", async () => {
+    const scssDeps = new Map<string, ReadonlySet<string>>();
+    scssDeps.set(
+      "/workspace/packages/test-angular-lib/src/comp.ts",
+      new Set(["/workspace/packages/test-angular-lib/scss/shared.scss"]),
+    );
+    mockCompileAsync.mockResolvedValue({
+      ...angularWatchCompileResult,
+      scssDependencies: scssDeps,
+    });
+
+    await workerFns["startWatch"](angularWatchInfo);
+
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockSend.mockClear();
+
+    // shared.scss 변경 → comp.ts도 modifiedFiles에 추가
+    await onChangeCallback([
+      { event: "change", path: "/workspace/packages/test-angular-lib/scss/shared.scss" },
+    ]);
+
+    expect(mockSend).toHaveBeenCalledWith("buildStart", {});
+    const compileCall = mockCompileAsync.mock.calls[mockCompileAsync.mock.calls.length - 1];
+    const modifiedFiles = compileCall[0] as Set<string>;
+    expect(modifiedFiles.has("/workspace/packages/test-angular-lib/scss/shared.scss")).toBe(true);
+    expect(modifiedFiles.has("/workspace/packages/test-angular-lib/src/comp.ts")).toBe(true);
+  });
+
+  // Acceptance: SCSS 변경 시 compileSideEffectScss 호출
+  it("calls compileSideEffectScss when scss files change", async () => {
+    mockCompileAsync.mockResolvedValue({ ...angularWatchCompileResult });
+
+    await workerFns["startWatch"](angularWatchInfo);
+
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockCompileSideEffectScss.mockClear();
+
+    await onChangeCallback([
+      { event: "change", path: "/workspace/packages/test-angular-lib/src/styles.scss" },
+      { event: "change", path: "/workspace/packages/test-angular-lib/src/index.ts" },
+    ]);
+
+    expect(mockCompileSideEffectScss).toHaveBeenCalledWith(
+      mockSideEffectScssRegistry,
+      expect.any(Array),
+      expect.any(Array),
+      expect.any(Map),
+      expect.any(Set), // changedScssFiles
+      expect.any(Map), // sideEffectScssDeps
+    );
+  });
+
+  // Unit: SCSS 미변경 시 compileSideEffectScss 미호출
+  it("does not call compileSideEffectScss when no scss changes", async () => {
+    mockCompileAsync.mockResolvedValue({ ...angularWatchCompileResult });
+
+    await workerFns["startWatch"](angularWatchInfo);
+
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockCompileSideEffectScss.mockClear();
+
+    await onChangeCallback([
+      { event: "change", path: "/workspace/packages/test-angular-lib/src/index.ts" },
+    ]);
+
+    expect(mockCompileSideEffectScss).not.toHaveBeenCalled();
+  });
+});
+
 describe("library-build.worker stopWatch()", () => {
   it("cleans up FsWatcher", async () => {
     await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });

package/tests/workers/server-build-lint.spec.ts

@@ -2,34 +2,35 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 
 // --- Mocks ---
 
-const { mockLintFn, MockLintWithProgramRunner } = vi.hoisted(() => {
-  const lintFn = vi.fn().mockResolvedValue({
-    success: true,
-    errorCount: 0,
-    warningCount: 0,
-    formattedOutput: "",
-  });
-  const RunnerCls = vi.fn().mockImplementation(function () {
-    return { lint: lintFn };
-  });
-  return { mockLintFn: lintFn, MockLintWithProgramRunner: RunnerCls };
-});
-
-vi.mock("../../src/lint/lint-with-program", () => ({
-  LintWithProgramRunner: MockLintWithProgramRunner,
-}));
-
-const mockTscResult = {
+// SdTsCompiler mock (js=false path) — lint result is part of compileAsync result
+const mockLintResult = {
   success: true,
-  errors: undefined,
-  diagnostics: [],
   errorCount: 0,
   warningCount: 0,
-  program: { getSourceFiles: () => [] },
+  formattedOutput: "",
 };
 
-vi.mock("../../src/utils/tsc-build", () => ({
-  runTscPackageBuild: vi.fn(() => mockTscResult),
+const mockCompileAsync = vi.fn(() => Promise.resolve({
+  program: { getSourceFiles: () => [] },
+  builderProgram: {},
+  isForAngular: false,
+  affectedFiles: undefined,
+  diagnostics: [],
+  errorCount: 0,
+  warningCount: 0,
+  errors: undefined as string[] | undefined,
+  emitResults: undefined,
+  lint: undefined as typeof mockLintResult | undefined,
+  scssErrors: [],
+  scssDependencies: new Map(),
+}));
+
+const MockSdTsCompiler = vi.fn().mockImplementation(function () {
+  return { compileAsync: mockCompileAsync };
+});
+
+vi.mock("../../src/ts-compiler/SdTsCompiler", () => ({
+  SdTsCompiler: MockSdTsCompiler,
 }));
 
 // tsc plugin mock (build() js=true path)
@@ -39,6 +40,7 @@ const mockTscPlugin = {
   getAffectedFiles: vi.fn(),
   getDiagnostics: vi.fn((): unknown[] => []),
   getErrors: vi.fn((): string[] | undefined => undefined),
+  getLintResult: vi.fn((): typeof mockLintResult | undefined => undefined),
   resetBuilderProgram: vi.fn(),
 };
 
@@ -114,25 +116,48 @@ await import("../../src/workers/server-build.worker");
 
 beforeEach(() => {
   vi.clearAllMocks();
-  mockLintFn.mockResolvedValue({
-    success: true,
+  mockCompileAsync.mockResolvedValue({
+    program: { getSourceFiles: () => [] },
+    builderProgram: {},
+    isForAngular: false,
+    affectedFiles: undefined,
+    diagnostics: [],
     errorCount: 0,
     warningCount: 0,
-    formattedOutput: "",
+    errors: undefined,
+    emitResults: undefined,
+    lint: undefined,
+    scssErrors: [],
+    scssDependencies: new Map(),
   });
-  mockTscResult.program = { getSourceFiles: () => [] } as any;
 
   // Reset tsc plugin mock
   mockTscPlugin.getProgram.mockReset();
   mockTscPlugin.getAffectedFiles.mockReset();
   mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
   mockTscPlugin.getErrors.mockReset().mockReturnValue(undefined);
+  mockTscPlugin.getLintResult.mockReset().mockReturnValue(undefined);
   mockTscPlugin.resetBuilderProgram.mockReset();
 });
 
 describe("server-build.worker lint integration (Slice 3)", () => {
-  describe("Scenario: server-build.worker runs lint after typecheck", () => {
-    it("returns lint result in build output when lint is enabled", async () => {
+  describe("Scenario: js=false lint via SdTsCompiler", () => {
+    it("returns lint result from SdTsCompiler when lint is enabled", async () => {
+      mockCompileAsync.mockResolvedValueOnce({
+        program: { getSourceFiles: () => [] },
+        builderProgram: {},
+        isForAngular: false,
+        affectedFiles: undefined,
+        diagnostics: [],
+        errorCount: 0,
+        warningCount: 0,
+        errors: undefined,
+        emitResults: undefined,
+        lint: mockLintResult,
+        scssErrors: [],
+        scssDependencies: new Map(),
+      });
+
       const result = await workerMethods["build"]({
         name: "my-server",
         cwd: "/workspace",
@@ -141,19 +166,13 @@ describe("server-build.worker lint integration (Slice 3)", () => {
       });
 
       expect(result).toHaveProperty("lint");
-      expect(result.lint).toEqual({
-        success: true,
-        errorCount: 0,
-        warningCount: 0,
-        formattedOutput: "",
-      });
+      expect(result.lint).toEqual(mockLintResult);
     });
   });
 
-  describe("Scenario: build js=true runs lint using tscPlugin.getProgram()", () => {
-    it("returns lint result using plugin program when js=true and lint enabled", async () => {
-      const fakeProgram = { getSourceFiles: () => [] };
-      mockTscPlugin.getProgram.mockReturnValue(fakeProgram);
+  describe("Scenario: js=true lint via tscPlugin.getLintResult()", () => {
+    it("returns lint result from tsc plugin when js=true and lint enabled", async () => {
+      mockTscPlugin.getLintResult.mockReturnValue(mockLintResult);
 
       const result = await workerMethods["build"]({
         name: "my-server",
@@ -163,12 +182,7 @@ describe("server-build.worker lint integration (Slice 3)", () => {
       });
 
       expect(result).toHaveProperty("lint");
-      expect(result.lint).toEqual({
-        success: true,
-        errorCount: 0,
-        warningCount: 0,
-        formattedOutput: "",
-      });
+      expect(result.lint).toEqual(mockLintResult);
     });
   });