@simplysm/sd-cli 14.0.10 → 14.0.12

package/tests/orchestrators/dev-watch-orchestrator.spec.ts

@@ -1373,8 +1373,8 @@ describe("DevWatchOrchestrator", () => {
       });
     }
 
-    // Acceptance: Scenario "Capacitor 디바이스 실행"
-    it("runs Capacitor.create + initialize + run(devServerUrl) after ViteDevServer starts", async () => {
+    // Acceptance: Scenario "Capacitor 초기화만 수행 (run 미호출)"
+    it("runs Capacitor.create + initialize but NOT run in dev mode", async () => {
       setupDefaults(createConfig({
         packages: {
           "my-client": {
@@ -1396,11 +1396,11 @@ describe("DevWatchOrchestrator", () => {
         undefined,
       );
       expect(mockCapacitorInstance.initialize).toHaveBeenCalled();
-      expect(mockCapacitorInstance.run).toHaveBeenCalledWith("http://localhost:4200");
+      expect(mockCapacitorInstance.run).not.toHaveBeenCalled();
     });
 
-    // Acceptance: Scenario "Electron 데스크톱 실행"
-    it("runs Electron.create + initialize + run(devServerUrl) after ViteDevServer starts", async () => {
+    // Acceptance: Scenario "dev 모드에서 Electron 미처리"
+    it("does not run Electron in dev mode even when electron config exists", async () => {
       setupDefaults(createConfig({
         packages: {
           "my-client": {
@@ -1416,17 +1416,13 @@ describe("DevWatchOrchestrator", () => {
       await orchestrator.initialize();
       await orchestrator.start();
 
-      expect(Electron.create).toHaveBeenCalledWith(
-        expect.stringContaining("my-client"),
-        { appId: "com.test.electron" },
-        undefined,
-      );
-      expect(mockElectronInstance.initialize).toHaveBeenCalled();
-      expect(mockElectronInstance.run).toHaveBeenCalledWith("http://localhost:4200");
+      expect(Electron.create).not.toHaveBeenCalled();
+      expect(mockElectronInstance.initialize).not.toHaveBeenCalled();
+      expect(mockElectronInstance.run).not.toHaveBeenCalled();
     });
 
-    // Acceptance: Scenario "Capacitor + Electron 동시 실행"
-    it("runs both Capacitor.run and Electron.run when both are configured", async () => {
+    // Acceptance: Scenario "Capacitor + Electron 동시 설정 시 Capacitor만 초기화"
+    it("initializes Capacitor but ignores Electron when both are configured", async () => {
       setupDefaults(createConfig({
         packages: {
           "my-client": {
@@ -1444,9 +1440,9 @@ describe("DevWatchOrchestrator", () => {
       await orchestrator.start();
 
       expect(Capacitor.create).toHaveBeenCalled();
-      expect(mockCapacitorInstance.run).toHaveBeenCalledWith("http://localhost:4200");
-      expect(Electron.create).toHaveBeenCalled();
-      expect(mockElectronInstance.run).toHaveBeenCalledWith("http://localhost:4200");
+      expect(mockCapacitorInstance.initialize).toHaveBeenCalled();
+      expect(mockCapacitorInstance.run).not.toHaveBeenCalled();
+      expect(Electron.create).not.toHaveBeenCalled();
     });
 
     // Acceptance: Scenario "네이티브 설정 없는 dev 모드"
@@ -1466,11 +1462,9 @@ describe("DevWatchOrchestrator", () => {
       expect(Electron.create).not.toHaveBeenCalled();
     });
 
-    // Acceptance: Scenario "dev 모드 종료 시 네��티브 프로세스 정리"
-    // Electron.run() blocks until SIGINT/SIGTERM — cleanup is handled by its internal signal handler.
-    // Capacitor.run() returns after deployment — no cleanup needed.
-    // This scenario verifies that shutdown() completes without error when native apps are running.
-    it("shutdown completes when native apps were launched", async () => {
+    // Acceptance: Scenario "dev 모드 종료 시 Capacitor 초기화 후 정상 종료"
+    // Capacitor.initialize()만 호출되므로 별도 정리 불필요.
+    it("shutdown completes when Capacitor was initialized", async () => {
       setupDefaults(createConfig({
         packages: {
           "my-client": {
@@ -1493,8 +1487,8 @@ describe("DevWatchOrchestrator", () => {
       }
     });
 
-    // Unit: native run error does not crash orchestrator
-    it("logs error but does not crash when Capacitor.run throws", async () => {
+    // Unit: Capacitor.initialize 에러는 로그만 남기고 크래시하지 않음
+    it("logs error but does not crash when Capacitor.initialize throws", async () => {
       setupDefaults(createConfig({
         packages: {
           "my-client": {
@@ -1505,81 +1499,15 @@ describe("DevWatchOrchestrator", () => {
         },
       }));
       setupEngineWithPort(4200);
-      mockCapacitorInstance.run.mockRejectedValue(new Error("device not found"));
+      mockCapacitorInstance.initialize.mockRejectedValue(new Error("init failed"));
 
       const orchestrator = new DevWatchOrchestrator({ mode: "dev", targets: [], options: [] });
       await orchestrator.initialize();
       // Should not throw
       await orchestrator.start();
 
-      expect(mockCapacitorInstance.run).toHaveBeenCalled();
-    });
-
-    // Unit: Electron.run is fire-and-forget (does not block dev mode start)
-    it("does not await Electron.run (fire-and-forget)", async () => {
-      let electronRunResolved = false;
-      mockElectronInstance.run.mockImplementation(() => {
-        return new Promise<void>((resolve) => {
-          // Simulate long-running Electron process — never resolves during test
-          setTimeout(() => {
-            electronRunResolved = true;
-            resolve();
-          }, 10_000);
-        });
-      });
-
-      setupDefaults(createConfig({
-        packages: {
-          "my-client": {
-            target: "client",
-            server: 4200,
-            electron: { appId: "com.test.electron" },
-          },
-        },
-      }));
-      setupEngineWithPort(4200);
-
-      const orchestrator = new DevWatchOrchestrator({ mode: "dev", targets: [], options: [] });
-      await orchestrator.initialize();
-      await orchestrator.start();
-
-      // start() returned without waiting for Electron.run to resolve
-      expect(electronRunResolved).toBe(false);
-      expect(mockElectronInstance.run).toHaveBeenCalled();
-    });
-
-    // Unit: DESIGN-004 — Electron run failure registers error in ResultCollector
-    it("registers error in ResultCollector when Electron.run fails", async () => {
-      mockElectronInstance.run.mockRejectedValue(new Error("electron crashed"));
-
-      setupDefaults(createConfig({
-        packages: {
-          "my-client": {
-            target: "client",
-            server: 4200,
-            electron: { appId: "com.test.electron" },
-          },
-        },
-      }));
-      setupEngineWithPort(4200);
-
-      const orchestrator = new DevWatchOrchestrator({ mode: "dev", targets: [], options: [] });
-      await orchestrator.initialize();
-      await orchestrator.start();
-
-      // Wait a tick for the fire-and-forget async to settle
-      await new Promise((resolve) => setTimeout(resolve, 50));
-
-      const resultCollector = vi.mocked(ResultCollector).mock.instances[0];
-      expect(resultCollector.add).toHaveBeenCalledWith(
-        expect.objectContaining({
-          name: "my-client",
-          target: "client",
-          type: "build",
-          status: "error",
-          message: expect.stringContaining("electron crashed"),
-        }),
-      );
+      expect(mockCapacitorInstance.initialize).toHaveBeenCalled();
+      expect(mockCapacitorInstance.run).not.toHaveBeenCalled();
     });
   });
 

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,32 @@ 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");
   });
 
-  // Acceptance: Scenario "사용자 코드의 import.meta.url을 치환한다"
-  it("sd-legacy-import-meta plugin replaces import.meta.url with module URL", 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);
+  // --- legacyModule esbuild.supported override (Feature 1.4) ---
 
-    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 () => {
+  // Acceptance: Scenario "legacyModule: true일 때 esbuild.supported에 import-meta/dynamic-import false 설정"
+  it("sets esbuild.supported to disable import-meta and dynamic-import when legacyModule is true", 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,
+        "dynamic-import": 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 +438,127 @@ 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$/);
+  });
+
+  // --- 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());