From a7197fc53b683fb55e71a6e664ca7196b1375546 Mon Sep 17 00:00:00 2001 From: Blomios Date: Fri, 17 Jul 2026 09:09:33 +0200 Subject: [PATCH] feat(frontend): produire un bundle web distinct en transport http (#74 F1) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Le transport est figé au build par Vite : un seul `dist` ne peut pas servir à la fois le desktop (IPC Tauri) et le navigateur (HTTP+WS). Le serveur embarqué servait donc un bundle desktop, d'où `__TAURI_INTERNALS__ is undefined` côté navigateur. - `vite.config.ts` devient une factory `({ mode })` : le mode par défaut émet le bundle desktop (`dist`), `--mode web` lit `.env.web` et émet le bundle navigateur (`dist-web`). - `.env.web` porte `VITE_TRANSPORT=http` dans un fichier de mode plutôt qu'en préfixe de commande, syntaxe qui n'existe pas sous Windows (bundle NSIS). - `transport.ts` extrait le prédicat `transportFromEnv()`, partagé par l'app et la config de build : le constant `__IDEA_TRANSPORT__` et le transport résolu dérivent de la même variable via le même prédicat, ils ne peuvent pas diverger. - `main.tsx` publie `__IDEA_TRANSPORT__` sur `window` : l'affectation est un effet de bord, elle survit à la minification et rend un bundle identifiable sans grep d'un symbole minifié. Les deux jeux d'adapters étant présents dans les deux bundles, leur présence ne prouve rien. Le chemin desktop est inchangé : le web reste opt-in. Co-Authored-By: Claude Opus 4.8 --- frontend/.env.web | 7 +++++ frontend/package.json | 2 ++ frontend/src/app/di.test.tsx | 23 ++++++++++++++++ frontend/src/app/di.tsx | 9 +++---- frontend/src/app/main.tsx | 8 ++++++ frontend/src/app/transport.ts | 19 +++++++++++++ frontend/src/vite-env.d.ts | 12 +++++++++ frontend/vite.config.ts | 50 ++++++++++++++++++++++++----------- frontend/vitest.config.ts | 9 +++++++ 9 files changed, 118 insertions(+), 21 deletions(-) create mode 100644 frontend/.env.web create mode 100644 frontend/src/app/transport.ts diff --git a/frontend/.env.web b/frontend/.env.web new file mode 100644 index 0000000..ee69b3f --- /dev/null +++ b/frontend/.env.web @@ -0,0 +1,7 @@ +# Vite mode `web` (`vite build --mode web`, ticket #74 lot F1): the bundle the +# embedded server serves to a browser talks HTTP+WS instead of Tauri IPC. +# +# This lives in a mode env file rather than an inline `VITE_TRANSPORT=http vite +# build` prefix because the npm scripts must also run on Windows (NSIS bundle), +# where that shell syntax does not exist. +VITE_TRANSPORT=http diff --git a/frontend/package.json b/frontend/package.json index 5251e7f..527ddfa 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -6,6 +6,8 @@ "scripts": { "dev": "vite", "build": "tsc --noEmit && vite build", + "build:web": "tsc --noEmit && vite build --mode web --outDir dist-web --emptyOutDir", + "build:bundle": "npm run typecheck && vite build --outDir dist --emptyOutDir && vite build --mode web --outDir dist-web --emptyOutDir", "typecheck": "tsc --noEmit", "preview": "vite preview", "test": "vitest run", diff --git a/frontend/src/app/di.test.tsx b/frontend/src/app/di.test.tsx index c5392fb..1454f9c 100644 --- a/frontend/src/app/di.test.tsx +++ b/frontend/src/app/di.test.tsx @@ -16,6 +16,7 @@ import { shouldUseMock, shouldUseHttp, } from "./di"; +import { transportFromEnv } from "./transport"; afterEach(() => { vi.unstubAllEnvs(); @@ -66,6 +67,28 @@ describe("resolveTransport / web (HTTP+WS) selection (ticket #13, F1)", () => { }); }); +describe("transportFromEnv (ticket #74, F1)", () => { + // The build config derives `__IDEA_TRANSPORT__` from this same predicate, so + // pinning it here pins both the runtime transport and the build constant. + it("selects http only for the exact opt-in value", () => { + expect(transportFromEnv("http")).toBe("http"); + }); + + it.each([undefined, "", "tauri", "HTTP", "http ", "web"])( + "falls back to tauri for %o", + (value) => { + expect(transportFromEnv(value)).toBe("tauri"); + }, + ); + + it("agrees with shouldUseHttp for the value the build reads", () => { + vi.stubEnv("VITE_TRANSPORT", "http"); + expect(shouldUseHttp()).toBe(transportFromEnv("http") === "http"); + vi.stubEnv("VITE_TRANSPORT", ""); + expect(shouldUseHttp()).toBe(transportFromEnv("") === "http"); + }); +}); + describe("DIProvider / useGateways", () => { it("provides explicit gateways to consumers", () => { const gateways = resolveGatewaysMock(); diff --git a/frontend/src/app/di.tsx b/frontend/src/app/di.tsx index a11a729..9b5eab7 100644 --- a/frontend/src/app/di.tsx +++ b/frontend/src/app/di.tsx @@ -18,11 +18,11 @@ import type { Gateways } from "@/ports"; import { createTauriGateways } from "@/adapters"; import { createMockGateways } from "@/adapters/mock"; import { createHttpWsGateways } from "@/adapters/http"; +import { transportFromEnv, type Transport } from "./transport"; const GatewaysContext = createContext(null); -/** The selected transport backing the gateways. */ -export type Transport = "mock" | "http" | "tauri"; +export type { Transport }; /** Whether the mock adapters should be used (env-driven, overridable in tests). */ export function shouldUseMock(): boolean { @@ -36,14 +36,13 @@ export function shouldUseMock(): boolean { * and is never affected (ticket #13, lot F1). */ export function shouldUseHttp(): boolean { - return import.meta.env.VITE_TRANSPORT === "http"; + return transportFromEnv(import.meta.env.VITE_TRANSPORT) === "http"; } /** Resolves which transport to use. Mock wins, then explicit web, else Tauri. */ export function resolveTransport(): Transport { if (shouldUseMock()) return "mock"; - if (shouldUseHttp()) return "http"; - return "tauri"; + return transportFromEnv(import.meta.env.VITE_TRANSPORT); } /** Resolves the gateway set for the current environment. */ diff --git a/frontend/src/app/main.tsx b/frontend/src/app/main.tsx index 3cb59f7..d2985d8 100644 --- a/frontend/src/app/main.tsx +++ b/frontend/src/app/main.tsx @@ -19,6 +19,14 @@ if (!root) { // follows the main window's focused project; otherwise the full app. const viewParams = parseViewWindowParams(window.location.search); +// Ticket #74, F1: publish the transport this bundle was built for. `define` +// inlines it as a literal, and assigning it is a side effect, so it survives +// minification and tree-shaking — a built bundle can be identified (by QA, or +// from devtools) without grepping for a minified symbol. Both adapter sets ship +// in either bundle, so their mere presence proves nothing. +(window as unknown as { __IDEA_TRANSPORT__?: string }).__IDEA_TRANSPORT__ = + __IDEA_TRANSPORT__; + // Ticket #13, F2: in web (HTTP) transport mode the browser client renders the // pairing-gated, read-only `WebApp`. Desktop (Tauri) is unchanged — it renders // the full `App` (or a detached view window). Detached windows are desktop-only. diff --git a/frontend/src/app/transport.ts b/frontend/src/app/transport.ts new file mode 100644 index 0000000..4725ee5 --- /dev/null +++ b/frontend/src/app/transport.ts @@ -0,0 +1,19 @@ +/** + * The transport signal, shared by the app and the Vite build config. + * + * `vite.config.ts` imports {@link transportFromEnv} to compute the + * `__IDEA_TRANSPORT__` build constant from the very same `VITE_TRANSPORT` + * variable that {@link shouldUseHttp} reads (ticket #74, F1). One predicate, + * one variable: the greppable constant and the resolved transport cannot drift. + */ + +/** The selected transport backing the gateways. */ +export type Transport = "mock" | "http" | "tauri"; + +/** + * The transport a raw `VITE_TRANSPORT` value selects, mock aside. Web is opt-in + * (`"http"`) so the desktop path stays the default and is never affected. + */ +export function transportFromEnv(value: string | undefined): "http" | "tauri" { + return value === "http" ? "http" : "tauri"; +} diff --git a/frontend/src/vite-env.d.ts b/frontend/src/vite-env.d.ts index d0a501f..1e5bb66 100644 --- a/frontend/src/vite-env.d.ts +++ b/frontend/src/vite-env.d.ts @@ -9,3 +9,15 @@ interface ImportMetaEnv { interface ImportMeta { readonly env: ImportMetaEnv; } + +/** + * The transport this bundle was built for, inlined as a literal by Vite + * `define` (ticket #74, F1). It is derived in `vite.config.ts` from the same + * `VITE_TRANSPORT` variable and the same `transportFromEnv()` predicate that + * `resolveTransport()` uses, so it always agrees with the adapters actually + * wired in — mock aside, which is a separate `VITE_USE_MOCK` switch. + * + * `main.tsx` publishes it on `window`, which makes it survive minification and + * lets a built bundle be identified without grepping for a minified symbol. + */ +declare const __IDEA_TRANSPORT__: "http" | "tauri"; diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts index bd67990..fe047a2 100644 --- a/frontend/vite.config.ts +++ b/frontend/vite.config.ts @@ -1,23 +1,41 @@ -import { defineConfig } from "vite"; +import { defineConfig, loadEnv } from "vite"; import react from "@vitejs/plugin-react"; import tailwindcss from "@tailwindcss/vite"; import { fileURLToPath, URL } from "node:url"; +import { transportFromEnv } from "./src/app/transport"; + +const root = fileURLToPath(new URL(".", import.meta.url)); + // Vite config tuned for Tauri v2 (fixed dev port, no clearing the terminal). -export default defineConfig({ - plugins: [react(), tailwindcss()], - resolve: { - alias: { - "@": fileURLToPath(new URL("./src", import.meta.url)), +// +// Two build artefacts (ticket #74): the default mode emits the desktop bundle +// (`dist`, Tauri IPC transport), and `--mode web` reads `.env.web` to emit the +// browser bundle served by the embedded server (`dist-web`, HTTP+WS transport). +export default defineConfig(({ mode }) => { + // Same env file resolution Vite applies to `import.meta.env`, so the + // `__IDEA_TRANSPORT__` constant below is computed from the exact variable + // `resolveTransport()` reads, through the exact same predicate (#74, F1). + const env = loadEnv(mode, root); + + return { + plugins: [react(), tailwindcss()], + resolve: { + alias: { + "@": fileURLToPath(new URL("./src", import.meta.url)), + }, }, - }, - clearScreen: false, - server: { - port: 5173, - strictPort: true, - }, - build: { - target: "es2021", - outDir: "dist", - }, + define: { + __IDEA_TRANSPORT__: JSON.stringify(transportFromEnv(env.VITE_TRANSPORT)), + }, + clearScreen: false, + server: { + port: 5173, + strictPort: true, + }, + build: { + target: "es2021", + outDir: "dist", + }, + }; }); diff --git a/frontend/vitest.config.ts b/frontend/vitest.config.ts index 0cab189..4263a85 100644 --- a/frontend/vitest.config.ts +++ b/frontend/vitest.config.ts @@ -3,6 +3,8 @@ import { defineConfig } from "vitest/config"; import react from "@vitejs/plugin-react"; import { fileURLToPath, URL } from "node:url"; +import { transportFromEnv } from "./src/app/transport"; + // Vitest config for the frontend hexagonal layers (domain/ports/adapters/app). // jsdom is used so React-Testing-Library can render the DI provider. export default defineConfig({ @@ -12,6 +14,13 @@ export default defineConfig({ "@": fileURLToPath(new URL("./src", import.meta.url)), }, }, + // Mirrors the build constant (#74, F1) through the same predicate, so code + // reading `__IDEA_TRANSPORT__` stays testable. + define: { + __IDEA_TRANSPORT__: JSON.stringify( + transportFromEnv(process.env.VITE_TRANSPORT), + ), + }, test: { environment: "jsdom", globals: true,