@simplysm/sd-cli 14.0.11 → 14.0.13

package/tests/electron/electron.spec.ts

@@ -23,8 +23,8 @@ vi.mock("@simplysm/core-node", () => ({
     glob: mockFsxGlob,
   },
   cpx: {
-    exec: mockCpxExec,
-    execSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
+    spawn: mockCpxSpawn,
+    spawnSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
   },
   pathx: {
     posixResolve: (...args: string[]) => path.resolve(...args).replace(/\\/g, "/"),
@@ -33,7 +33,7 @@ vi.mock("@simplysm/core-node", () => ({
 }));
 
 // cpx mock (was execa)
-const mockCpxExec = vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+const mockCpxSpawn = vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
 
 // esbuild mock
 const mockEsbuildBuild = vi.fn().mockResolvedValue({});
@@ -75,7 +75,9 @@ vi.mock("consola", () => ({
       warn: mockLoggerWarn,
       info: mockLoggerInfo,
     }),
+    level: 0,
   },
+  LogLevels: { debug: 4 },
 }));
 
 //#endregion
@@ -105,7 +107,7 @@ function setupDefaultMocks() {
     }
     return Promise.resolve([]);
   });
-  mockCpxExec.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+  mockCpxSpawn.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
   mockEsbuildBuild.mockResolvedValue({});
 }
 
@@ -179,7 +181,7 @@ describe("Electron", () => {
 
       expect(findElectronPackageJson()).toBeDefined();
 
-      const execaCalls = mockCpxExec.mock.calls;
+      const execaCalls = mockCpxSpawn.mock.calls;
       expect(
         execaCalls.find((c) => c[0] === "npm" && (c[1] as string[]).includes("install")),
       ).toBeDefined();
@@ -196,7 +198,7 @@ describe("Electron", () => {
       const electron = await Electron.create(PKG_PATH, { appId: "com.test.app" });
       await electron.initialize();
 
-      const rebuildCall = mockCpxExec.mock.calls.find(
+      const rebuildCall = mockCpxSpawn.mock.calls.find(
         (c) => typeof c[0] === "string" && c[0].includes("electron-rebuild"),
       );
       expect(rebuildCall).toBeUndefined();
@@ -453,7 +455,7 @@ describe("Electron", () => {
       const electronKill = vi.fn();
       let resolveElectron: () => void = () => {};
 
-      mockCpxExec.mockImplementation((cmd: string) => {
+      mockCpxSpawn.mockImplementation((cmd: string) => {
         if (typeof cmd === "string" && cmd.includes("electron")) {
           // Electron process: create a deferred promise we can resolve externally
           const p = new Promise<void>((resolve) => {
@@ -535,7 +537,7 @@ describe("Electron", () => {
   describe("단위: run() 플러그인 동작", () => {
     it("passes custom env and ELECTRON_DEV_URL via esbuild banner", async () => {
       let resolveElectron: () => void = () => {};
-      mockCpxExec.mockImplementation((cmd: string) => {
+      mockCpxSpawn.mockImplementation((cmd: string) => {
         if (typeof cmd === "string" && cmd.includes("electron")) {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
@@ -568,7 +570,7 @@ describe("Electron", () => {
 
     it("calls initialize() before starting esbuild context", async () => {
       let resolveElectron: () => void = () => {};
-      mockCpxExec.mockImplementation((cmd: string) => {
+      mockCpxSpawn.mockImplementation((cmd: string) => {
         if (typeof cmd === "string" && cmd.includes("electron")) {
           const p = new Promise<void>((resolve) => {
             resolveElectron = resolve;
@@ -588,7 +590,7 @@ describe("Electron", () => {
       await runPromise;
 
       // initialize calls npm install -> execa should have been called with npm install
-      const npmInstallCall = mockCpxExec.mock.calls.find(
+      const npmInstallCall = mockCpxSpawn.mock.calls.find(
         (c: any[]) => c[0] === "npm" && (c[1] as string[]).includes("install"),
       );
       expect(npmInstallCall).toBeDefined();

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

@@ -263,6 +263,43 @@ describe("BaseEngine", () => {
       await engine.stop();
     });
 
+    it("calls resolver on error event to release RebuildManager batch", async () => {
+      const mockResolver = vi.fn();
+      const mockRebuildManager = { registerBuild: vi.fn(() => mockResolver) };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        // Trigger initial build to move past isInitialBuild
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({ build: { success: true } });
+      });
+
+      const engine = new TscEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        rebuildManager: mockRebuildManager as any,
+      });
+
+      await engine.startWatch({ js: true, dts: true });
+
+      // Simulate rebuild cycle: buildStart -> error (no build event)
+      const buildStartHandler = mockWorker.on.mock.calls.find(
+        (call: any[]) => call[0] === "buildStart",
+      )?.[1];
+      const errorHandler = mockWorker.on.mock.calls.find(
+        (call: any[]) => call[0] === "error",
+      )?.[1];
+
+      buildStartHandler?.({});
+      expect(mockRebuildManager.registerBuild).toHaveBeenCalled();
+
+      errorHandler?.({ message: "Worker crashed" });
+      expect(mockResolver).toHaveBeenCalled();
+
+      await engine.stop();
+    });
+
     it("uses _getTarget() for BuildResult target", async () => {
       const mockResultCollector = { add: vi.fn() };
 

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

@@ -191,6 +191,30 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
+    // Acceptance: Scenario "exclude 전달 (build)"
+    it("passes exclude from config to worker build call", async () => {
+      mockWorker.build.mockResolvedValue({ success: true });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({
+          config: {
+            target: "client",
+            server: "my-server",
+            exclude: ["jeep-sqlite"],
+          } as any,
+        }),
+      });
+      await engine.run({ js: true, dts: false });
+
+      expect(mockWorker.build).toHaveBeenCalledWith(
+        expect.objectContaining({
+          exclude: ["jeep-sqlite"],
+        }),
+      );
+      await engine.stop();
+    });
+
     // Unit: build failure reflects in result
     it("reflects build failure in result", async () => {
       mockWorker.build.mockResolvedValue({
@@ -265,11 +289,18 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
-    // Acceptance: Scenario "ResultCollector에 결과 보고"
-    it("reports build result to ResultCollector", async () => {
+    // Acceptance: Scenario "ResultCollector에 결과 보고 — build 이벤트 경유"
+    it("reports build result to ResultCollector via build event only", async () => {
       const mockResultCollector = { add: vi.fn() };
 
-      mockWorker.startWatch.mockResolvedValue({ success: true });
+      mockWorker.startWatch.mockImplementation(() => {
+        // Simulate "build" event during startWatch (Angular plugin buildStart)
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({ success: true });
+        return Promise.resolve({ success: true });
+      });
 
       const engine = new ViteEngine({
         cwd: "/root",
@@ -388,6 +419,32 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
+    // Acceptance: Scenario "exclude 전달 (watch)"
+    it("passes exclude from config to worker startWatch call", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({
+          config: {
+            target: "client",
+            server: "my-server",
+            exclude: ["jeep-sqlite", "another-pkg"],
+          } as any,
+        }),
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(mockWorker.startWatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          exclude: ["jeep-sqlite", "another-pkg"],
+        }),
+      );
+
+      await engine.stop();
+    });
+
     // Unit: server: string does not pass port
     it("does not pass port when config.server is a string", async () => {
       mockWorker.startWatch.mockResolvedValue({ success: true });
@@ -480,6 +537,61 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
+    // Unit: mock worker가 serverReady를 발행하지 않으면 port가 undefined로 남는다
+    it("leaves port undefined when worker mock does not emit serverReady for legacyModule", async () => {
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({
+          config: {
+            target: "client",
+            server: "my-server",
+            browserSupport: { legacyModule: true },
+          } as any,
+        }),
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      // serverReady is subscribed but never emitted — port stays undefined
+      expect(engine.port).toBeUndefined();
+
+      // buildStart/build event handlers are still registered
+      expect(mockWorker.on).toHaveBeenCalledWith("buildStart", expect.any(Function));
+      expect(mockWorker.on).toHaveBeenCalledWith("build", expect.any(Function));
+
+      await engine.stop();
+    });
+
+    // Unit: initial build result is reported exactly once (not duplicated by startWatch return)
+    it("reports initial build result exactly once to ResultCollector", async () => {
+      const mockResultCollector = { add: vi.fn() };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({ success: true });
+        return Promise.resolve({ success: true });
+      });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      const buildAddCalls = mockResultCollector.add.mock.calls.filter(
+        (c: any[]) => c[0].type === "build",
+      );
+      expect(buildAddCalls).toHaveLength(1);
+
+      await engine.stop();
+    });
+
     // Unit: error event reports to ResultCollector
     it("reports error from error event to ResultCollector", async () => {
       const mockResultCollector = { add: vi.fn() };

package/tests/utils/vite-config.spec.ts

@@ -221,8 +221,8 @@ describe("createClientViteConfig", () => {
 
   // --- legacyModule (Feature 1.1) ---
 
-  // Acceptance: Scenario "legacyModule을 활성화한다"
-  it("enables inlineDynamicImports and import.meta plugin when legacyModule is true", async () => {
+  // Acceptance: Scenario "legacyModule 활성화 시 inlineDynamicImports만 설정한다"
+  it("enables inlineDynamicImports without import.meta plugin when legacyModule is true", async () => {
     const config = await createClientViteConfig({
       ...createDefaultOptions(),
       legacyModule: true,
@@ -230,26 +230,22 @@ describe("createClientViteConfig", () => {
 
     // inlineDynamicImports가 활성화된다
     expect((config.build as any)?.rollupOptions?.output?.inlineDynamicImports).toBe(true);
-    // import.meta 치환 플러그인이 활성화된다
+    // import.meta 치환 플러그인이 없다 (esbuild target이 자동 치환)
     const plugins = config.plugins as Array<{ name: string }>;
     const legacyPlugin = plugins.find((p) => p.name === "sd-legacy-import-meta");
-    expect(legacyPlugin).toBeDefined();
+    expect(legacyPlugin).toBeUndefined();
   });
 
-  // Acceptance: Scenario "legacyModule을 설정하지 않는다"
-  it("does not set inlineDynamicImports or import.meta plugin when legacyModule is not set", async () => {
+  // Acceptance: Scenario "legacyModule 미설정 시 코드 분할이 기본 동작한다"
+  it("does not set inlineDynamicImports when legacyModule is not set", async () => {
     const config = await createClientViteConfig(createDefaultOptions());
 
     // 코드 분할이 기본 동작한다
     expect(config.build?.rollupOptions).toBeUndefined();
-    // import.meta가 그대로 유지된다
-    const plugins = config.plugins as Array<{ name: string }>;
-    const legacyPlugin = plugins.find((p) => p.name === "sd-legacy-import-meta");
-    expect(legacyPlugin).toBeUndefined();
   });
 
-  // Acceptance: Scenario "기존 splitting 옵션을 legacyModule로 마이그레이션한다"
-  it("legacyModule: true provides inlineDynamicImports plus import.meta plugin (splitting replacement)", async () => {
+  // Acceptance: Scenario "legacyModule: true는 inlineDynamicImports를 활성화한다"
+  it("legacyModule: true provides inlineDynamicImports (splitting replacement)", async () => {
     const config = await createClientViteConfig({
       ...createDefaultOptions(),
       legacyModule: true,
@@ -257,95 +253,31 @@ describe("createClientViteConfig", () => {
 
     // 기존 splitting: false와 동일한 inlineDynamicImports 동작
     expect((config.build as any)?.rollupOptions?.output?.inlineDynamicImports).toBe(true);
-    // 추가로 import.meta 치환이 활성화된다
-    const plugins = config.plugins as Array<{ name: string }>;
-    const legacyPlugin = plugins.find((p) => p.name === "sd-legacy-import-meta");
-    expect(legacyPlugin).toBeDefined();
   });
 
-  // Unit: enforce: "post" 설정 확인 (D4)
-  it("sd-legacy-import-meta plugin has enforce: post", async () => {
-    const config = await createClientViteConfig({
-      ...createDefaultOptions(),
-      legacyModule: true,
-    });
-
-    const plugins = config.plugins as Array<{ name: string; enforce?: string }>;
-    const legacyPlugin = plugins.find((p) => p.name === "sd-legacy-import-meta");
-    expect(legacyPlugin?.enforce).toBe("post");
-  });
+  // --- legacyModule esbuild.supported override (Feature 1.4) ---
 
-  // Acceptance: Scenario "사용자 코드의 import.meta.url을 치환한다"
-  it("sd-legacy-import-meta plugin replaces import.meta.url with module URL", async () => {
+  // Acceptance: Scenario "legacyModule: true일 때 esbuild.supported에 import-meta false 설정"
+  it("sets esbuild.supported to disable import-meta when legacyModule is true", async () => {
     const config = await createClientViteConfig({
       ...createDefaultOptions(),
       legacyModule: true,
     });
 
-    const plugins = config.plugins as Array<{ name: string; enforce?: string; transform?: Function }>;
-    const legacyPlugin = plugins.find((p) => p.name === "sd-legacy-import-meta");
-    expect(legacyPlugin).toBeDefined();
-
-    const code = 'const url = import.meta.url;';
-    const id = "/packages/my-client/src/app.ts";
-    const result = legacyPlugin!.transform!(code, id);
-
-    expect(result).toBeDefined();
-    expect(result.code).toContain(JSON.stringify(id));
-    expect(result.code).not.toContain("import.meta");
-  });
-
-  // Acceptance: Scenario "Vite가 주입한 import.meta.hot을 치환한다"
-  it("sd-legacy-import-meta plugin replaces import.meta.hot injected by Vite", async () => {
-    const config = await createClientViteConfig({
-      ...createDefaultOptions(),
-      legacyModule: true,
-    });
-
-    const plugins = config.plugins as Array<{ name: string; transform?: Function }>;
-    const legacyPlugin = plugins.find((p) => p.name === "sd-legacy-import-meta");
-
-    const code = 'import.meta.hot = createHotContext("/src/app.ts");';
-    const id = "/packages/my-client/src/app.ts";
-    const result = legacyPlugin!.transform!(code, id);
-
-    expect(result).toBeDefined();
-    expect(result.code).not.toContain("import.meta");
-  });
-
-  // Acceptance: Scenario "/@vite/client의 import.meta를 치환한다"
-  it("sd-legacy-import-meta plugin replaces import.meta in /@vite/client", async () => {
-    const config = await createClientViteConfig({
-      ...createDefaultOptions(),
-      legacyModule: true,
-    });
-
-    const plugins = config.plugins as Array<{ name: string; transform?: Function }>;
-    const legacyPlugin = plugins.find((p) => p.name === "sd-legacy-import-meta");
-
-    const code = 'const base = import.meta.url;';
-    const id = "/@vite/client";
-    const result = legacyPlugin!.transform!(code, id);
-
-    expect(result).toBeDefined();
-    expect(result.code).not.toContain("import.meta");
+    const esbuildOpts = config.esbuild as Record<string, unknown> | undefined;
+    expect(esbuildOpts?.["supported"]).toEqual(
+      expect.objectContaining({
+        "import-meta": false,
+      }),
+    );
   });
 
-  // Acceptance: Scenario "import.meta가 없는 모듈은 변환하지 않는다"
-  it("sd-legacy-import-meta plugin returns undefined for modules without import.meta", async () => {
-    const config = await createClientViteConfig({
-      ...createDefaultOptions(),
-      legacyModule: true,
-    });
-
-    const plugins = config.plugins as Array<{ name: string; transform?: Function }>;
-    const legacyPlugin = plugins.find((p) => p.name === "sd-legacy-import-meta");
-
-    const code = 'const x = 1 + 2;';
-    const id = "/packages/my-client/src/utils.ts";
-    const result = legacyPlugin!.transform!(code, id);
+  // Acceptance: Scenario "legacyModule 미설정 시 esbuild.supported 변경 없음"
+  it("does not set esbuild.supported when legacyModule is not specified", async () => {
+    const config = await createClientViteConfig(createDefaultOptions());
 
-    expect(result).toBeUndefined();
+    const esbuildOpts = config.esbuild as Record<string, unknown> | undefined;
+    expect(esbuildOpts?.["supported"]).toBeUndefined();
   });
 
   // --- PWA (Feature 5.2) ---
@@ -505,6 +437,146 @@ describe("createClientViteConfig", () => {
     );
   });
 
+  // --- watch option (Feature 1.2: legacy dev mode) ---
+
+  // Acceptance: Scenario "watch: true 시 build.watch 설정 및 emptyOutDir: false"
+  it("sets build.watch and emptyOutDir: false when watch is true in build mode", async () => {
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      mode: "build",
+      watch: true,
+    });
+
+    expect(config.build?.watch).toEqual({});
+    expect(config.build?.emptyOutDir).toBe(false);
+    expect(config.logLevel).toBeUndefined();
+  });
+
+  // Acceptance: Scenario "watch: true + replaceDeps 시 sdScopeWatchPlugin 포함"
+  it("includes sdScopeWatchPlugin when watch is true with replaceDeps in build mode", async () => {
+    const { sdScopeWatchPlugin } = await import("../../src/utils/vite-scope-watch-plugin");
+
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      mode: "build",
+      watch: true,
+      replaceDeps: [{ packageName: "@scope/core", sourcePath: "/packages/core" }],
+    });
+
+    const plugins = config.plugins as Array<{ name: string }>;
+    const scopePlugin = plugins.find((p) => p.name === "sd-scope-watch-plugin");
+    expect(scopePlugin).toBeDefined();
+    expect(sdScopeWatchPlugin).toHaveBeenCalled();
+  });
+
+  // Acceptance: Scenario "watch 미설정 시 기존 build 동작 유지"
+  it("sets emptyOutDir: true and logLevel: silent when watch is not set in build mode", async () => {
+    const config = await createClientViteConfig(createDefaultOptions());
+
+    expect(config.build?.emptyOutDir).toBe(true);
+    expect(config.logLevel).toBe("silent");
+    expect(config.build?.watch).toBeUndefined();
+  });
+
+  // Unit: watch: true without replaceDeps does not add sdScopeWatchPlugin
+  it("does not add sdScopeWatchPlugin in watch mode without replaceDeps", async () => {
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      mode: "build",
+      watch: true,
+    });
+
+    const plugins = config.plugins as Array<{ name: string }>;
+    const scopePlugin = plugins.find((p) => p.name === "sd-scope-watch-plugin");
+    expect(scopePlugin).toBeUndefined();
+  });
+
+  // Unit: watch: true still sets outDir
+  it("sets outDir in watch mode", async () => {
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      mode: "build",
+      watch: true,
+    });
+
+    expect(config.build?.outDir).toContain("my-client");
+    expect(config.build?.outDir).toMatch(/dist$/);
+  });
+
+  // --- outDir override ---
+
+  // Acceptance: Scenario "outDir 설정 시 해당 경로로 빌드 출력"
+  it("uses custom outDir when provided", async () => {
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      outDir: "/packages/my-client/.capacitor/www",
+    });
+
+    expect(config.build?.outDir).toBe("/packages/my-client/.capacitor/www");
+  });
+
+  // Acceptance: Scenario "outDir 미설정 시 pkgDir/dist 사용"
+  it("defaults outDir to pkgDir/dist when not provided", async () => {
+    const config = await createClientViteConfig(createDefaultOptions());
+
+    expect(config.build?.outDir).toMatch(/my-client[\\/]dist$/);
+  });
+
+  // --- exclude (Feature 1.1: vite-exclude-passthrough) ---
+
+  // Acceptance: Scenario "exclude에 패키지를 지정하면 pre-bundling에서 제외된다"
+  it("sets optimizeDeps.exclude when exclude is provided", async () => {
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      mode: "dev",
+      exclude: ["jeep-sqlite"],
+    });
+
+    expect(config.optimizeDeps?.exclude).toEqual(["jeep-sqlite"]);
+  });
+
+  // Acceptance: Scenario "exclude 미설정 시 기존 동작과 동일하다"
+  it("does not set optimizeDeps.exclude when exclude is not provided", async () => {
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      mode: "dev",
+    });
+
+    expect(config.optimizeDeps?.exclude).toBeUndefined();
+  });
+
+  // Acceptance: Scenario "exclude와 replaceDeps가 모두 있으면 둘 다 제외된다"
+  it("sets optimizeDeps.exclude from exclude while sdScopeWatchPlugin handles replaceDeps", async () => {
+    const { sdScopeWatchPlugin } = await import("../../src/utils/vite-scope-watch-plugin");
+
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      mode: "dev",
+      exclude: ["jeep-sqlite"],
+      replaceDeps: [{ packageName: "@scope/core", sourcePath: "/packages/core" }],
+    });
+
+    // Base config에 exclude 설정
+    expect(config.optimizeDeps?.exclude).toEqual(["jeep-sqlite"]);
+    // sdScopeWatchPlugin도 호출됨 (replaceDeps용 exclude는 plugin이 처리)
+    expect(sdScopeWatchPlugin).toHaveBeenCalled();
+  });
+
+  // Acceptance: Scenario "exclude만 있고 replaceDeps가 없으면 exclude만 제외된다"
+  it("sets optimizeDeps.exclude from exclude when no replaceDeps", async () => {
+    const config = await createClientViteConfig({
+      ...createDefaultOptions(),
+      mode: "dev",
+      exclude: ["jeep-sqlite"],
+    });
+
+    expect(config.optimizeDeps?.exclude).toEqual(["jeep-sqlite"]);
+    // sdScopeWatchPlugin은 호출되지 않음
+    const plugins = config.plugins as Array<{ name: string }>;
+    const scopePlugin = plugins.find((p) => p.name === "sd-scope-watch-plugin");
+    expect(scopePlugin).toBeUndefined();
+  });
+
   // Acceptance: Scenario "pwa 필드 미설정 시 기본값"
   it("uses default manifest values from pkgName when pwa is undefined", async () => {
     await createClientViteConfig(createDefaultOptions());