@simplysm/sd-cli 14.0.19 → 14.0.22

package/tests/utils/lint-core.spec.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Hoisted mock references — available inside vi.mock factories
+const mocks = vi.hoisted(() => ({
+  fsxExists: vi.fn<(path: string) => Promise<boolean>>(),
+  fsxGlob: vi.fn<(...args: unknown[]) => Promise<string[]>>(),
+  filterByTargets: vi.fn(
+    (files: string[], _targets: string[], _cwd: string) => files,
+  ),
+  lintFiles: vi.fn<() => Promise<Array<{ errorCount: number; warningCount: number }>>>(),
+  loadFormatter: vi.fn(),
+  outputFixes: vi.fn(),
+  jitiImport: vi.fn(),
+  eslintCtor: vi.fn(),
+}));
+
+vi.mock("@simplysm/core-node", () => ({
+  fsx: { exists: mocks.fsxExists, glob: mocks.fsxGlob },
+  pathx: { filterByTargets: mocks.filterByTargets },
+}));
+
+vi.mock("eslint", () => ({
+  ESLint: class MockESLint {
+    constructor(options: unknown) { mocks.eslintCtor(options); }
+    lintFiles = mocks.lintFiles;
+    loadFormatter = mocks.loadFormatter;
+    static outputFixes = mocks.outputFixes;
+  },
+}));
+
+vi.mock("jiti", () => ({
+  createJiti: vi.fn(() => ({ import: mocks.jitiImport })),
+}));
+
+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 { loadIgnorePatterns, executeLint } = await import("../../src/utils/lint-core");
+
+//#region loadIgnorePatterns
+
+describe("loadIgnorePatterns", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("extracts globalIgnores patterns from eslint config", async () => {
+    mocks.fsxExists.mockImplementation((p) =>
+      Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
+    );
+    mocks.jitiImport.mockResolvedValue({
+      default: [
+        { ignores: ["dist/**", "node_modules/**"] },
+        { files: ["*.ts"], rules: {} }, // not globalIgnores — has files key
+        { ignores: [".cache/**"] },
+      ],
+    });
+
+    const result = await loadIgnorePatterns("/project");
+    expect(result).toEqual(["dist/**", "node_modules/**", ".cache/**"]);
+  });
+
+  it("ignores config objects that have files key", async () => {
+    mocks.fsxExists.mockImplementation((p) =>
+      Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
+    );
+    mocks.jitiImport.mockResolvedValue({
+      default: [{ files: ["*.ts"], ignores: ["dist/**"] }],
+    });
+
+    const result = await loadIgnorePatterns("/project");
+    expect(result).toEqual([]);
+  });
+
+  it("throws when no eslint config file found", async () => {
+    mocks.fsxExists.mockResolvedValue(false);
+
+    await expect(loadIgnorePatterns("/project")).rejects.toThrow(
+      "ESLint 설정 파일",
+    );
+  });
+});
+
+//#endregion
+
+//#region executeLint
+
+describe("executeLint", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Default: eslint config exists with no ignores
+    mocks.fsxExists.mockImplementation((p) =>
+      Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
+    );
+    mocks.jitiImport.mockResolvedValue({ default: [] });
+    mocks.fsxGlob.mockResolvedValue(["/project/src/a.ts", "/project/src/b.ts"]);
+    mocks.filterByTargets.mockImplementation((files) => files);
+    mocks.lintFiles.mockResolvedValue([{ errorCount: 0, warningCount: 0 }]);
+    mocks.loadFormatter.mockResolvedValue({
+      format: vi.fn().mockResolvedValue(""),
+    });
+  });
+
+  it("lints all collected files and returns success when no errors", async () => {
+    const result = await executeLint({ targets: [], fix: false, timing: false });
+
+    expect(result.success).toBe(true);
+    expect(result.errorCount).toBe(0);
+    expect(result.warningCount).toBe(0);
+    expect(mocks.lintFiles).toHaveBeenCalled();
+  });
+
+  it("filters files by targets via pathx.filterByTargets", async () => {
+    const filteredFiles = ["/project/packages/core-common/src/a.ts"];
+    mocks.filterByTargets.mockReturnValue(filteredFiles);
+
+    await executeLint({ targets: ["packages/core-common"], fix: false, timing: false });
+
+    expect(mocks.filterByTargets).toHaveBeenCalledWith(
+      expect.any(Array),
+      ["packages/core-common"],
+      expect.any(String),
+    );
+  });
+
+  it("applies auto-fix when fix option is true", async () => {
+    await executeLint({ targets: [], fix: true, timing: false });
+
+    expect(mocks.outputFixes).toHaveBeenCalled();
+  });
+
+  it("sets TIMING env variable when timing option is true", async () => {
+    const origTiming = process.env["TIMING"];
+
+    await executeLint({ targets: [], fix: false, timing: true });
+
+    expect(process.env["TIMING"]).toBe("1");
+
+    // Cleanup
+    if (origTiming == null) delete process.env["TIMING"];
+    else process.env["TIMING"] = origTiming;
+  });
+
+  it("creates ESLint with cache enabled and correct cache location", async () => {
+    await executeLint({ targets: [], fix: false, timing: false });
+
+    expect(mocks.eslintCtor).toHaveBeenCalledWith(
+      expect.objectContaining({
+        cache: true,
+        cacheLocation: expect.stringContaining("eslint.cache"),
+      }),
+    );
+  });
+
+  it("returns error count and formatted output when lint errors found", async () => {
+    mocks.lintFiles.mockResolvedValue([
+      { errorCount: 3, warningCount: 1 },
+      { errorCount: 1, warningCount: 2 },
+    ]);
+    mocks.loadFormatter.mockResolvedValue({
+      format: vi.fn().mockResolvedValue("error details"),
+    });
+
+    const result = await executeLint({ targets: [], fix: false, timing: false });
+
+    expect(result.success).toBe(false);
+    expect(result.errorCount).toBe(4);
+    expect(result.warningCount).toBe(3);
+    expect(result.formattedOutput).toBe("error details");
+  });
+
+  it("returns success when no files to lint", async () => {
+    mocks.fsxGlob.mockResolvedValue([]);
+
+    const result = await executeLint({ targets: [], fix: false, timing: false });
+
+    expect(result.success).toBe(true);
+    expect(mocks.lintFiles).not.toHaveBeenCalled();
+  });
+});
+
+//#endregion

package/tests/utils/server-production-files-import-paths.verify.md

@@ -0,0 +1,14 @@
+# server-build.worker 비즈니스 로직 분리 — LLM 검증
+
+## 검증 항목
+
+- [x] 4개 함수가 utils/server-production-files.ts에 export되어 있다: line 14, 27, 68, 87에 각각 export function 확인
+- [x] worker에서 4개 함수 정의가 제거되었다: worker에 함수 정의 없음, import와 호출만 존재
+- [x] worker에서 collectAllExternals, generateProductionFiles를 새 모듈에서 import한다: line 19 `import { collectAllExternals, generateProductionFiles } from "../utils/server-production-files"`
+- [x] collectAllExternals 시그니처: `(pkgDir: string, manualExternals?: string[]) => string[]` — line 14 확인
+- [x] parseLockfileVersions 시그니처: `(cwd: string) => Map<string, string>` — line 27 확인
+- [x] resolveLockedVersions 시그니처: `(cwd: string, pkgNames: string[]) => Record<string, string>` — line 68 확인
+- [x] generateProductionFiles 시그니처: `(info: ServerBuildInfo, externals: string[]) => void` — line 87 확인
+- [x] worker에 build, rebuildAll, startWatch, stopWatch, cleanup, createEsbuildWatchContext가 존재한다: line 116, 148, 259, 336, 359, 488 확인
+- [x] worker에서 cpx import가 제거되었다: grep 결과 매칭 없음
+- [x] worker에서 collectAllDependencyExternals import가 제거되었다: grep 결과 매칭 없음

package/tests/workers/client-worker.spec.ts

@@ -737,4 +737,96 @@ describe("client.worker", () => {
       await workerFns["stopWatch"]();
     });
   });
+
+  describe("build", () => {
+    // Acceptance: Scenario "Angular 컴파일 에러 시 빌드 실패 반환"
+    it("returns failure with errors when Angular compilation fails", async () => {
+      let capturedOnBuild: ((result: any) => void) | undefined;
+      mockCreateClientViteConfig.mockImplementation((opts: any) => {
+        capturedOnBuild = opts.onBuild;
+        return { plugins: [] };
+      });
+
+      mockViteBuild.mockImplementation(() => {
+        capturedOnBuild?.({
+          success: false,
+          errors: ["TS2345: type mismatch"],
+          warnings: [],
+        });
+      });
+
+      const result = await workerFns["build"](createBaseInfo());
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain("TS2345: type mismatch");
+    });
+
+    // Acceptance: Scenario "Angular 컴파일 에러 없이 빌드 성공"
+    it("returns success when Angular compilation has no errors", async () => {
+      let capturedOnBuild: ((result: any) => void) | undefined;
+      mockCreateClientViteConfig.mockImplementation((opts: any) => {
+        capturedOnBuild = opts.onBuild;
+        return { plugins: [] };
+      });
+
+      mockViteBuild.mockImplementation(() => {
+        capturedOnBuild?.({ success: true });
+      });
+
+      const result = await workerFns["build"](createBaseInfo());
+
+      expect(result.success).toBe(true);
+      expect(result.errors).toBeUndefined();
+    });
+
+    // Acceptance: Scenario "Angular 컴파일 경고만 있을 때 성공 반환"
+    it("returns success with warnings when compilation has warnings only", async () => {
+      let capturedOnBuild: ((result: any) => void) | undefined;
+      mockCreateClientViteConfig.mockImplementation((opts: any) => {
+        capturedOnBuild = opts.onBuild;
+        return { plugins: [] };
+      });
+
+      mockViteBuild.mockImplementation(() => {
+        capturedOnBuild?.({
+          success: true,
+          warnings: ["deprecated API usage"],
+        });
+      });
+
+      const result = await workerFns["build"](createBaseInfo());
+
+      expect(result.success).toBe(true);
+      expect(result.warnings).toContain("deprecated API usage");
+    });
+
+    // Unit: lint result is still captured alongside compilation result
+    it("captures lint result from onBuild callback", async () => {
+      let capturedOnBuild: ((result: any) => void) | undefined;
+      mockCreateClientViteConfig.mockImplementation((opts: any) => {
+        capturedOnBuild = opts.onBuild;
+        return { plugins: [] };
+      });
+
+      const lintData = { success: true, errorCount: 0, warningCount: 0, formattedOutput: "" };
+      mockViteBuild.mockImplementation(() => {
+        capturedOnBuild?.({ success: true, lint: lintData });
+      });
+
+      const result = await workerFns["build"](createBaseInfo());
+
+      expect(result.success).toBe(true);
+      expect(result.lint).toEqual(lintData);
+    });
+
+    // Unit: returns success true when onBuild is never called (non-Angular framework)
+    it("returns success true when onBuild is never called", async () => {
+      mockCreateClientViteConfig.mockResolvedValue({ plugins: [] });
+      mockViteBuild.mockResolvedValue(undefined);
+
+      const result = await workerFns["build"](createBaseInfo());
+
+      expect(result.success).toBe(true);
+    });
+  });
 });

package/tests/workers/server-build-context-dispose.verify.md

@@ -0,0 +1,8 @@
+# esbuild context dispose 안전성 -- LLM 검증
+
+## 검증 항목
+
+- [x] try-finally 패턴 적용: `server-build.worker.ts:434-442` — oldContext 캡처 후 try 블록에서 새 context 생성, finally에서 oldContext.dispose() 호출
+- [x] 성공 시 dispose: try 블록에서 새 context 생성 성공 → finally에서 oldContext.dispose() 실행
+- [x] 실패 시 dispose: createEsbuildWatchContext() 예외 시 → finally에서 oldContext.dispose() 실행 보장
+- [x] null 안전: `if (oldContext != null)` 가드로 oldContext가 없는 경우(output.js=false 등) 안전

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

@@ -716,6 +716,45 @@ describe("server-build.worker startWatch()", () => {
     await workerFns["startWatch"](watchInfo);
     await expect(workerFns["startWatch"](watchInfo)).rejects.toThrow("already been called");
   });
+
+  // Acceptance: esbuild context creation failure leaves safe state (LOGIC-001)
+  it("allows tsc-only rebuilds after esbuild context recreation failure", async () => {
+    // Provide metafile inputs so subsequent change passes the metafile filter
+    mockMetafileInputs = { "packages/my-server/src/main.ts": {} };
+
+    await workerFns["startWatch"](watchInfo);
+
+    const onChangeHandler = mockOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    // After dispose, rebuild should throw (simulates real disposed context)
+    mockDispose.mockImplementation(() => {
+      mockRebuild.mockRejectedValue(new Error("Build context already disposed"));
+    });
+
+    // Make context() throw to simulate creation failure
+    vi.mocked(esbuild.context).mockRejectedValueOnce(new Error("context creation failed"));
+    mockSend.mockClear();
+
+    // File add triggers context recreation → fails → sends "error"
+    await onChangeHandler([{ event: "add", path: "/workspace/packages/my-server/src/new.ts" }]);
+    expect(mockDispose).toHaveBeenCalled();
+
+    // Subsequent file change should work without "disposed" errors
+    mockSend.mockClear();
+    const absPath = path.resolve("/workspace", "packages/my-server/src/main.ts").replace(/\\/g, "/");
+    await onChangeHandler([{ event: "change", path: absPath }]);
+
+    // Should NOT get "disposed" error
+    const errorCalls = mockSend.mock.calls.filter((c) => c[0] === "error");
+    for (const [, data] of errorCalls) {
+      expect((data as { message: string }).message).not.toContain("disposed");
+    }
+    // Build event should be sent (tsc-only result)
+    const buildCalls = mockSend.mock.calls.filter((c) => c[0] === "build");
+    expect(buildCalls.length).toBeGreaterThanOrEqual(1);
+  });
 });
 
 describe("server-build.worker stopWatch()", () => {