@simplysm/sd-cli 14.0.38 → 14.0.39

package/tests/esbuild/esbuild-tsc-plugin.spec.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type esbuild from "esbuild";
+import type { TscPackageBuildResult } from "../../src/utils/tsc-build";
+
+//#region Mocks
+
+const mockRunTscPackageBuild = vi.fn<(...args: unknown[]) => TscPackageBuildResult>();
+
+vi.mock("../../src/utils/tsc-build", () => ({
+  runTscPackageBuild: (...args: unknown[]) => mockRunTscPackageBuild(...args),
+}));
+
+const mockParseTsconfig = vi.fn();
+
+vi.mock("../../src/utils/tsconfig", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/utils/tsconfig")>();
+  return {
+    ...actual,
+    parseTsconfig: (...args: unknown[]) => mockParseTsconfig(...args),
+  };
+});
+
+//#endregion
+
+const { createTscPlugin } = await import("../../src/esbuild/esbuild-tsc-plugin");
+
+/** esbuild 플러그인 lifecycle을 시뮬레이션하는 헬퍼 */
+function setupPlugin(plugin: esbuild.Plugin) {
+  let onStartCb: (() => esbuild.OnStartResult | null | void | Promise<esbuild.OnStartResult | null | void>) | undefined;
+  let onEndCb: ((result: esbuild.BuildResult) => esbuild.OnEndResult | null | void | Promise<esbuild.OnEndResult | null | void>) | undefined;
+
+  const mockBuild = {
+    onStart(cb: typeof onStartCb) { onStartCb = cb; },
+    onEnd(cb: typeof onEndCb) { onEndCb = cb; },
+  } as unknown as esbuild.PluginBuild;
+
+  void plugin.setup(mockBuild);
+
+  return {
+    async invokeOnStart() {
+      return (await onStartCb?.()) ?? null;
+    },
+    async invokeOnEnd(result?: Partial<esbuild.BuildResult>) {
+      return (await onEndCb?.({
+        errors: [],
+        warnings: [],
+        mangleCache: {},
+        outputFiles: [],
+        metafile: { inputs: {}, outputs: {} },
+        ...result,
+      } as esbuild.BuildResult)) ?? null;
+    },
+  };
+}
+
+const baseOptions = {
+  pkgDir: "/workspace/packages/my-server",
+  cwd: "/workspace",
+  output: { dts: true },
+};
+
+const mockParsedConfig = {
+  options: { target: 99 },
+  fileNames: [],
+  errors: [],
+} as any;
+
+function createSuccessTscResult(): TscPackageBuildResult {
+  return {
+    success: true,
+    diagnostics: [],
+    errorCount: 0,
+    warningCount: 0,
+    program: { getSourceFiles: () => [] } as any,
+    affectedFiles: new Set(["/workspace/packages/my-server/src/main.ts"]),
+    builderProgram: {} as any,
+  };
+}
+
+describe("createTscPlugin — Unit Tests", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockParseTsconfig.mockReturnValue(mockParsedConfig);
+    mockRunTscPackageBuild.mockReturnValue(createSuccessTscResult());
+  });
+
+  describe("plugin 구조", () => {
+    it("setup 함수가 onStart와 onEnd를 등록한다", () => {
+      const result = createTscPlugin(baseOptions);
+      const onStartSpy = vi.fn();
+      const onEndSpy = vi.fn();
+
+      const mockBuild = {
+        onStart: onStartSpy,
+        onEnd: onEndSpy,
+      } as unknown as esbuild.PluginBuild;
+
+      void result.plugin.setup(mockBuild);
+
+      expect(onStartSpy).toHaveBeenCalledOnce();
+      expect(onEndSpy).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("onStart — runTscPackageBuild 옵션 전달", () => {
+    it("pkgDir, cwd, output.dts를 올바르게 전달한다", async () => {
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+        expect.objectContaining({
+          pkgDir: "/workspace/packages/my-server",
+          cwd: "/workspace",
+          output: { js: false, dts: true },
+          parsedConfig: mockParsedConfig,
+        }),
+      );
+    });
+
+    it("output.dts가 false일 때도 정확하게 전달한다", async () => {
+      const result = createTscPlugin({
+        ...baseOptions,
+        output: { dts: false },
+      });
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+        expect.objectContaining({
+          output: { js: false, dts: false },
+        }),
+      );
+    });
+  });
+
+  describe("onEnd — 상태 저장", () => {
+    it("tsc 결과의 diagnostics를 정확히 저장한다", async () => {
+      const diagnostics = [
+        { category: 0, code: 6031, messageText: "Watching for changes" },
+        { category: 1, code: 2322, messageText: "Type error" },
+      ];
+      mockRunTscPackageBuild.mockReturnValue({
+        ...createSuccessTscResult(),
+        diagnostics,
+      });
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(result.getDiagnostics()).toEqual(diagnostics);
+    });
+
+    it("parseTsconfig 예외 시에도 에러를 저장한다", async () => {
+      mockParseTsconfig.mockImplementation(() => {
+        throw new Error("Invalid tsconfig.json");
+      });
+
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(result.getErrors()).toEqual(["Invalid tsconfig.json"]);
+      expect(result.getDiagnostics()).toEqual([]);
+      expect(result.getProgram()).toBeUndefined();
+    });
+  });
+
+  describe("getter — 연속 빌드", () => {
+    it("두 번째 빌드 결과가 첫 번째 결과를 덮어쓴다", async () => {
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      // 첫 번째 빌드 — 에러
+      const errorResult: TscPackageBuildResult = {
+        success: false,
+        errors: ["first error"],
+        diagnostics: [{ category: 1, code: 1, messageText: "err" }],
+        errorCount: 1,
+        warningCount: 0,
+      };
+      mockRunTscPackageBuild.mockReturnValue(errorResult);
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+      expect(result.getErrors()).toEqual(["first error"]);
+
+      // 두 번째 빌드 — 성공
+      mockRunTscPackageBuild.mockReturnValue(createSuccessTscResult());
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+      expect(result.getErrors()).toBeUndefined();
+      expect(result.getProgram()).toBeDefined();
+    });
+  });
+
+  describe("resetBuilderProgram", () => {
+    it("빌드 전 호출해도 에러가 발생하지 않는다", () => {
+      const result = createTscPlugin(baseOptions);
+      expect(() => result.resetBuilderProgram()).not.toThrow();
+    });
+
+    it("여러 번 호출해도 안전하다", async () => {
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      result.resetBuilderProgram();
+      result.resetBuilderProgram();
+
+      // 리셋 후 빌드 가능
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(mockRunTscPackageBuild).toHaveBeenLastCalledWith(
+        expect.objectContaining({ oldBuilderProgram: undefined }),
+      );
+    });
+  });
+});

package/tests/utils/esbuild-client-config-postcss.verify.md

@@ -0,0 +1,6 @@
+# Feature 1.2 client 빌드 PostCSS 설정 통합 — LLM 검증
+
+## 검증 항목
+
+- [x] postcssConfigPath가 CreateClientEsbuildOptions 인터페이스에서 제거됨: `esbuild-client-config.ts`에서 `postcssConfigPath` 검색 결과 없음 (No matches found). `client.worker.ts`에서도 2곳 모두 제거 확인.
+- [x] createScssPlugin에 로딩된 PostCSS 인스턴스가 전달됨: `esbuild-client-config.ts:118`에서 `postcssPlugins: loadedPostcssPlugins`로 `createScssPlugin`에 전달 확인.

package/tests/utils/esbuild-client-config.acc.spec.ts

@@ -37,6 +37,19 @@ vi.mock("browserslist-to-esbuild", () => ({
   default: vi.fn(() => ["chrome61"]),
 }));
 
+vi.mock("module", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("module")>();
+  return {
+    ...actual,
+    createRequire: vi.fn(() => (name: string) => {
+      if (name === "nonexistent-plugin") {
+        throw new Error(`Cannot find module '${name}'`);
+      }
+      return (..._args: any[]) => ({ postcssPlugin: name });
+    }),
+  };
+});
+
 // --- Imports (after mocks) ---
 
 const { createClientEsbuildContext } = await import(
@@ -171,7 +184,7 @@ describe("createClientEsbuildContext — Acceptance", () => {
   });
 
   // Scenario: 커스텀 env 주입
-  it("env 설정 시 import.meta.env.KEY로 define에 주입", async () => {
+  it("env 설정 시 import.meta.env 객체로 define에 주입", async () => {
     await createClientEsbuildContext({
       pkgDir: "/workspace/packages/my-app",
       cwd: "/workspace",
@@ -180,27 +193,26 @@ describe("createClientEsbuildContext — Acceptance", () => {
     });
 
     const esbuildOptions = vi.mocked(esbuild.context).mock.calls[0][0];
-    expect(esbuildOptions.define!["import.meta.env.API_URL"]).toBe(
-      '"https://api.example.com"',
+    expect(esbuildOptions.define!["import.meta.env"]).toBe(
+      JSON.stringify({ API_URL: "https://api.example.com", DEBUG: "true" }),
     );
-    expect(esbuildOptions.define!["import.meta.env.DEBUG"]).toBe('"true"');
   });
 
-  // Scenario: PostCSS 설정 전달
-  it("postcssPlugins 전달 시 BundleStylesheetOptions.postcssConfiguration에 반영", async () => {
+  // Scenario: PostCSS 설정 — postcssConfiguration 비활성화 + sd-postcss 등록
+  it("postcssPlugins 전달 시 postcssConfiguration은 undefined이고 sd-postcss 플러그인이 등록된다", async () => {
     await createClientEsbuildContext({
       pkgDir: "/workspace/packages/my-app",
       cwd: "/workspace",
       mode: "build",
       postcssPlugins: [["autoprefixer", {}]],
-      postcssConfigPath: "/workspace/packages/my-app",
     });
 
     const [, styleOpts] = vi.mocked(createCompilerPlugin).mock.calls[0];
-    expect(styleOpts.postcssConfiguration).toEqual({
-      config: { plugins: [["autoprefixer", {}]] },
-      configPath: "/workspace/packages/my-app",
-    });
+    expect(styleOpts.postcssConfiguration).toBeUndefined();
+
+    const esbuildOptions = vi.mocked(esbuild.context).mock.calls[0][0];
+    const pluginNames = esbuildOptions.plugins!.map((p: any) => p.name);
+    expect(pluginNames).toContain("sd-postcss");
   });
 
   // Scenario: 프로덕션 일회성 빌드
@@ -358,8 +370,8 @@ describe("createClientEsbuildContext — Acceptance", () => {
     ]);
   });
 
-  // Scenario: dev 모드 출력 네이밍 (해시 없음)
-  it("dev 모드: entryNames, chunkNames, assetNames 모두 [name]", async () => {
+  // Scenario: dev 모드 출력 네이밍 (entry/asset은 해시 없음, chunk은 해시 포함)
+  it("dev 모드: entryNames, assetNames는 [name], chunkNames는 [name]-[hash]", async () => {
     await createClientEsbuildContext({
       pkgDir: "/workspace/packages/my-app",
       cwd: "/workspace",
@@ -368,7 +380,7 @@ describe("createClientEsbuildContext — Acceptance", () => {
 
     const esbuildOptions = vi.mocked(esbuild.context).mock.calls[0][0];
     expect(esbuildOptions.entryNames).toBe("[name]");
-    expect(esbuildOptions.chunkNames).toBe("[name]");
+    expect(esbuildOptions.chunkNames).toBe("[name]-[hash]");
     expect(esbuildOptions.assetNames).toBe("[name]");
   });
 

package/tests/utils/esbuild-client-config.spec.ts

@@ -39,6 +39,19 @@ vi.mock("browserslist-to-esbuild", () => ({
   default: vi.fn(() => ["chrome61"]),
 }));
 
+vi.mock("module", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("module")>();
+  return {
+    ...actual,
+    createRequire: vi.fn(() => (name: string) => {
+      if (name === "nonexistent-plugin") {
+        throw new Error(`Cannot find module '${name}'`);
+      }
+      return (..._args: any[]) => ({ postcssPlugin: name });
+    }),
+  };
+});
+
 // --- Imports (after mocks) ---
 
 const { createClientEsbuildContext } = await import(
@@ -108,22 +121,19 @@ describe("createClientEsbuildContext — define 생성", () => {
     expect(opts.define!["ngHmrMode"]).toBe("false");
   });
 
-  it("env가 없으면 import.meta.env 관련 define 없음", async () => {
+  it("env가 없으면 import.meta.env define 없음", async () => {
     await createClientEsbuildContext(baseDev);
     const opts = vi.mocked(esbuild.context).mock.calls[0][0];
-    const envKeys = Object.keys(opts.define!).filter((k) =>
-      k.startsWith("import.meta.env."),
-    );
-    expect(envKeys).toHaveLength(0);
+    expect(opts.define!["import.meta.env"]).toBeUndefined();
   });
 
-  it("env 값에 특수문자가 있으면 JSON.stringify로 이스케이프", async () => {
+  it("env 설정 시 import.meta.env 객체로 define에 주입", async () => {
     await createClientEsbuildContext({
       ...baseBuild,
       env: { MSG: 'hello "world"' },
     });
     const opts = vi.mocked(esbuild.context).mock.calls[0][0];
-    expect(opts.define!["import.meta.env.MSG"]).toBe('"hello \\"world\\""');
+    expect(opts.define!["import.meta.env"]).toBe(JSON.stringify({ MSG: 'hello "world"' }));
   });
 });
 
@@ -160,13 +170,65 @@ describe("createClientEsbuildContext — PostCSS 설정", () => {
     expect(styleOpts.postcssConfiguration).toBeUndefined();
   });
 
-  it("postcssConfigPath 미전달 시 pkgDir을 기본값으로 사용", async () => {
+  it("postcssPlugins 전달해도 postcssConfiguration은 항상 undefined", async () => {
     await createClientEsbuildContext({
       ...baseBuild,
       postcssPlugins: [["autoprefixer"]],
     });
     const [, styleOpts] = vi.mocked(createCompilerPlugin).mock.calls[0];
-    expect(styleOpts.postcssConfiguration!.configPath).toBe(baseBuild.pkgDir);
+    expect(styleOpts.postcssConfiguration).toBeUndefined();
+  });
+});
+
+describe("createClientEsbuildContext — PostCSS 플러그인 통합", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("postcssPlugins 전달 시 sd-postcss 플러그인이 plugins에 등록된다", async () => {
+    await createClientEsbuildContext({
+      ...baseBuild,
+      postcssPlugins: [["autoprefixer"]],
+    });
+    const opts = vi.mocked(esbuild.context).mock.calls[0][0];
+    const pluginNames = opts.plugins!.map((p: any) => p.name);
+    expect(pluginNames).toContain("sd-postcss");
+  });
+
+  it("postcssPlugins 미전달 시 sd-postcss 미등록", async () => {
+    await createClientEsbuildContext(baseBuild);
+    const opts = vi.mocked(esbuild.context).mock.calls[0][0];
+    const pluginNames = opts.plugins!.map((p: any) => p.name);
+    expect(pluginNames).not.toContain("sd-postcss");
+  });
+
+  it("sd-postcss가 customPlugins 뒤, sd-legacy-strip-dynamic-import 앞에 배치된다", async () => {
+    const customPlugin = { name: "custom", setup: vi.fn() };
+    await createClientEsbuildContext({
+      ...baseBuild,
+      postcssPlugins: [["autoprefixer"]],
+      plugins: [customPlugin as any],
+      legacyModule: true,
+      onEnd: vi.fn(),
+    });
+    const opts = vi.mocked(esbuild.context).mock.calls[0][0];
+    const pluginNames = opts.plugins!.map((p: any) => p.name);
+
+    const customIdx = pluginNames.indexOf("custom");
+    const postcssIdx = pluginNames.indexOf("sd-postcss");
+    const stripIdx = pluginNames.indexOf("sd-legacy-strip-dynamic-import");
+    const onEndIdx = pluginNames.indexOf("sd-on-end");
+
+    expect(postcssIdx).toBeGreaterThan(customIdx);
+    expect(postcssIdx).toBeLessThan(stripIdx);
+    expect(postcssIdx).toBeLessThan(onEndIdx);
+  });
+
+  it("존재하지 않는 플러그인 이름으로 에러가 throw된다", async () => {
+    await expect(
+      createClientEsbuildContext({
+        ...baseBuild,
+        postcssPlugins: [["nonexistent-plugin"]],
+      }),
+    ).rejects.toThrow("nonexistent-plugin");
   });
 });
 
@@ -471,8 +533,8 @@ describe("createClientEsbuildContext — legacyModule 설정", () => {
       env: { API_URL: "https://api.example.com" },
     });
     const opts = vi.mocked(esbuild.context).mock.calls[0][0];
-    expect(opts.define!["import.meta.env.API_URL"]).toBe(
-      JSON.stringify("https://api.example.com"),
+    expect(opts.define!["import.meta.env"]).toBe(
+      JSON.stringify({ API_URL: "https://api.example.com" }),
     );
     expect(opts.supported).toEqual({ "import-meta": false });
   });