litestar-vite 0.13.1__tar.gz → 0.13.2__tar.gz

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/.gitignore

@@ -167,3 +167,8 @@ cython_debug/
 
 node_modules
 .aider*
+
+.DS_Store
+*.swo
+*.swp
+.venv

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: litestar-vite
-Version: 0.13.1
+Version: 0.13.2
 Summary: Vite plugin for Litestar
 Project-URL: Changelog, https://cofin.github.io/litestar-vite/latest/changelog
 Project-URL: Discord, https://discord.gg/X3FJqy8d2j

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/pyproject.toml

@@ -25,7 +25,7 @@ license = { text = "MIT" }
 name = "litestar-vite"
 readme = "README.md"
 requires-python = ">=3.9"
-version = "0.13.1"
+version = "0.13.2"
 
 [project.urls]
 Changelog = "https://cofin.github.io/litestar-vite/latest/changelog"
@@ -83,7 +83,7 @@ test = [
 allow_dirty = true
 commit = true
 commit_args = "--no-verify"
-current_version = "0.13.1"
+current_version = "0.13.2"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"
@@ -279,6 +279,7 @@ lint.ignore = [
   "PLC2701", # private import
   "S704",
   "S404",
+  "PLR6301"
 ]
 lint.select = ["ALL"]
 src = ["src/py/litestar_vite", "src/py/tests"]

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/src/js/src/index.ts

@@ -291,17 +291,12 @@ function resolveLitestarPlugin(pluginConfig: Required<PluginConfig>): LitestarPl
         // Run middleware early to intercept before Vite's base/HTML handlers
         server.middlewares.use(async (req, res, next) => {
           const indexPath = await findIndexHtmlPath(server, pluginConfig)
-
-          // Check if index.html exists AND the request is for the root or /index.html
           if (indexPath && (req.url === "/" || req.url === "/index.html")) {
+            const currentUrl = req.url
             try {
               const htmlContent = await fs.promises.readFile(indexPath, "utf-8")
               // Transform the HTML using Vite's pipeline
-              const transformedHtml = await server.transformIndexHtml(
-                "/", // Use '/' as the URL for transformation context to ensure scripts are injected correctly relative to root
-                htmlContent,
-                req.originalUrl,
-              )
+              const transformedHtml = await server.transformIndexHtml(req.originalUrl ?? currentUrl, htmlContent, req.originalUrl)
               res.statusCode = 200
               res.setHeader("Content-Type", "text/html")
               res.end(transformedHtml)
@@ -673,5 +668,14 @@ function resolveDevelopmentEnvironmentTld(configPath: string): string {
  * The directory of the current file.
  */
 function dirname(): string {
-  return fileURLToPath(new URL(".", import.meta.url))
+  // Use path.resolve relative to process.cwd() as a more robust alternative
+  // Assumes the script runs from the project root or similar predictable location.
+  // Adjust the relative path if necessary based on actual execution context.
+  try {
+    // Attempt original method first
+    return fileURLToPath(new URL(".", import.meta.url))
+  } catch {
+    // Fallback for environments where import.meta.url is problematic (like some test runners)
+    return path.resolve(process.cwd(), "src/js/src")
+  }
 }

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/src/js/tests/index.test.ts

@@ -1,4 +1,5 @@
 import fs from "node:fs"
+import path from "node:path"
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 import litestar from "../src"
 import { getRelativeUrlPath, isCurrentRoute, isRoute, resolvePageComponent, route, toRoute } from "../src/inertia-helpers"
@@ -8,22 +9,35 @@ vi.mock("fs", async () => {
   const actual = await vi.importActual<typeof import("fs")>("fs")
 
   return {
+    promises: actual.promises,
     default: {
       ...actual,
       existsSync: (path: string) => ["resources/", "assets/", "src/"].includes(path) || actual.existsSync(path),
+      readFileSync: actual.readFileSync,
+      mkdirSync: actual.mkdirSync,
+      writeFileSync: actual.writeFileSync,
+      rmSync: actual.rmSync,
     },
   }
 })
+
+// Read actual placeholder content for assertions
+const actualPlaceholderContent = fs.readFileSync(path.resolve(__dirname, "../src/dev-server-index.html"), "utf-8")
+
 // Mock process.env
 const originalEnv = process.env
 beforeEach(() => {
   vi.resetModules()
   process.env = { ...originalEnv }
+  vi.clearAllMocks()
+  vi.spyOn(fs.promises, "access").mockRestore()
+  vi.spyOn(fs.promises, "readFile").mockRestore()
 })
 
 afterEach(() => {
   process.env = originalEnv
   vi.clearAllMocks()
+  vi.restoreAllMocks()
 })
 
 // Mock routes for testing
@@ -526,159 +540,217 @@ describe("litestar-vite-plugin", () => {
     let mockRes: any
     let mockNext: any
     let plugin: any
+    let serverHook: any
+    const testRootDir = "/test/root"
+    const testResourceDir = "resources"
+    const testPublicDir = "public"
+
+    const rootIndexPath = path.join(testRootDir, "index.html")
+    const resourceIndexPath = path.join(testRootDir, testResourceDir, "index.html")
+    const publicIndexPath = path.join(testRootDir, testPublicDir, "index.html")
+    // Use original placeholder path logic
+    const placeholderPath = path.resolve(__dirname, "..", "src", "dev-server-index.html")
 
     beforeEach(() => {
-      // Mock Vite dev server with complete config
+      vi.clearAllMocks()
+    })
+
+    const setupServer = async (pluginOptions = {}, serverConfig = {}) => {
       mockServer = {
         config: {
-          root: "/test/root",
+          root: testRootDir,
           envDir: process.cwd(),
           mode: "development",
           base: "/",
           server: {
             origin: "http://localhost:5173",
           },
+          logger: { info: vi.fn(), error: vi.fn() },
+          ...serverConfig,
         },
-        transformIndexHtml: vi.fn().mockResolvedValue("<html>transformed</html>"),
+        transformIndexHtml: vi.fn().mockImplementation(async (_url, html) => `<html>transformed ${html}</html>`),
         middlewares: {
           use: vi.fn().mockImplementation((middleware) => {
             mockMiddleware = middleware
           }),
         },
       }
-
-      // Mock response object
       mockRes = {
         statusCode: 0,
         setHeader: vi.fn(),
         end: vi.fn(),
       }
-
-      // Mock next function
       mockNext = vi.fn()
 
-      // Mock fs promises
-      vi.spyOn(fs.promises, "access").mockResolvedValue(undefined)
-      vi.spyOn(fs.promises, "readFile").mockResolvedValue("<html>test</html>")
-
-      // Initialize plugin and call configResolved
       plugin = litestar({
         input: "resources/js/app.js",
-        resourceDirectory: "resources",
+        resourceDirectory: testResourceDir,
+        autoDetectIndex: true,
+        ...pluginOptions,
       })[0]
 
-      // Call configResolved to set up resolvedConfig
       plugin.configResolved?.(mockServer.config)
-    })
 
-    it("serves index.html when detected", async () => {
-      // Mock findIndexHtmlPath to return a path
-      vi.spyOn(fs.promises, "access").mockResolvedValueOnce(undefined)
+      const hookResult = await plugin.configureServer?.(mockServer)
+      serverHook = typeof hookResult === "function" ? hookResult : hookResult?.()
 
-      // Configure the server
-      const serverHook = await plugin.configureServer?.(mockServer)
-      // @ts-ignore - Server hook can be a function or object with handler
-      if (serverHook && typeof serverHook === "function") {
-        await serverHook()
+      if (typeof serverHook === "function") {
+        serverHook()
       }
+    }
 
-      // Call the middleware with root path
-      await mockMiddleware(
-        {
-          url: "/",
-          originalUrl: "/",
-        },
-        mockRes,
-        mockNext,
-      )
+    const mockFs = (foundPath: string | null) => {
+      // Only mock access here
+      vi.spyOn(fs.promises, "access").mockImplementation(async (p) => {
+        if (p === foundPath) return undefined
+        throw new Error("File not found")
+      })
+    }
+
+    it("serves index.html from root when detected", async () => {
+      await setupServer()
+      mockFs(rootIndexPath)
+      vi.spyOn(fs.promises, "readFile").mockResolvedValue("<html>root</html>")
+      await mockMiddleware({ url: "/", originalUrl: "/" }, mockRes, mockNext)
 
-      // Verify the response
       expect(mockRes.statusCode).toBe(200)
       expect(mockRes.setHeader).toHaveBeenCalledWith("Content-Type", "text/html")
-      expect(mockRes.end).toHaveBeenCalledWith("<html>transformed</html>")
+      expect(mockServer.transformIndexHtml).toHaveBeenCalledWith("/", "<html>root</html>", "/")
+      expect(mockRes.end).toHaveBeenCalledWith("<html>transformed <html>root</html></html>")
       expect(mockNext).not.toHaveBeenCalled()
     })
 
-    it("serves placeholder when index.html is not detected", async () => {
-      // Mock findIndexHtmlPath to return null
-      vi.spyOn(fs.promises, "access").mockRejectedValueOnce(new Error("File not found"))
-
-      // Mock the placeholder file read
-      const placeholderContent = `<html>
-        <head>
-          <title>Litestar Vite</title>
-        </head>
-        <body>
-          <div id="app"></div>
-        </body>
-      </html>`
-
-      // Mock transformIndexHtml to only transform non-placeholder content
-      mockServer.transformIndexHtml = vi.fn().mockImplementation((url, html) => {
-        if (html.includes("Litestar Vite")) {
-          return html // Don't transform placeholder content
-        }
-        return "<html>transformed</html>" // Transform other content
-      })
+    it("serves index.html from resource directory when detected", async () => {
+      await setupServer()
+      mockFs(resourceIndexPath)
+      vi.spyOn(fs.promises, "readFile").mockResolvedValue("<html>resource</html>")
+      await mockMiddleware({ url: "/index.html", originalUrl: "/index.html" }, mockRes, mockNext)
 
-      vi.spyOn(fs.promises, "readFile").mockResolvedValueOnce(placeholderContent)
+      expect(mockRes.statusCode).toBe(200)
+      expect(mockRes.setHeader).toHaveBeenCalledWith("Content-Type", "text/html")
+      expect(mockServer.transformIndexHtml).toHaveBeenCalledWith("/index.html", "<html>resource</html>", "/index.html")
+      expect(mockRes.end).toHaveBeenCalledWith("<html>transformed <html>resource</html></html>")
+      expect(mockNext).not.toHaveBeenCalled()
+    })
 
-      // Configure the server
-      const serverHook = await plugin.configureServer?.(mockServer)
-      // @ts-ignore - Server hook can be a function or object with handler
-      if (serverHook && typeof serverHook === "function") {
-        await serverHook()
-      }
+    it("serves index.html from public directory when detected", async () => {
+      await setupServer()
+      mockFs(publicIndexPath)
+      vi.spyOn(fs.promises, "readFile").mockResolvedValue("<html>public</html>")
+      await mockMiddleware({ url: "/", originalUrl: "/" }, mockRes, mockNext)
 
-      // Call the middleware with /index.html path
-      await mockMiddleware(
-        {
-          url: "/index.html",
-          originalUrl: "/index.html",
-        },
-        mockRes,
-        mockNext,
-      )
+      expect(mockRes.statusCode).toBe(200)
+      expect(mockRes.setHeader).toHaveBeenCalledWith("Content-Type", "text/html")
+      expect(mockServer.transformIndexHtml).toHaveBeenCalledWith("/", "<html>public</html>", "/")
+      expect(mockRes.end).toHaveBeenCalledWith("<html>transformed <html>public</html></html>")
+      expect(mockNext).not.toHaveBeenCalled()
+    })
+
+    it("serves placeholder when index.html is not detected and url is /index.html", async () => {
+      const appUrl = "http://test.app"
+      process.env.APP_URL = appUrl // Set env BEFORE setupServer
+      await setupServer()
+      mockFs(null)
+      // No specific readFile mock needed, relies on actual file read via robust dirname
+
+      await mockMiddleware({ url: "/index.html", originalUrl: "/index.html" }, mockRes, mockNext)
 
-      // Verify the response
       expect(mockRes.statusCode).toBe(200)
       expect(mockRes.setHeader).toHaveBeenCalledWith("Content-Type", "text/html")
-      expect(mockRes.end).toHaveBeenCalledWith(expect.stringContaining("Litestar Vite"))
+      // Expect actual content with replaced URL
+      expect(mockRes.end).toHaveBeenCalledWith(actualPlaceholderContent.replace(/{{ APP_URL }}/g, appUrl))
+      expect(mockServer.transformIndexHtml).not.toHaveBeenCalled()
       expect(mockNext).not.toHaveBeenCalled()
     })
 
-    it("passes through non-index.html requests", async () => {
-      // Configure the server
-      const serverHook = await plugin.configureServer?.(mockServer)
-      // @ts-ignore - Server hook can be a function or object with handler
-      if (serverHook && typeof serverHook === "function") {
-        await serverHook()
-      }
+    it("calls next() when index.html is not detected and url is /", async () => {
+      await setupServer()
+      mockFs(null)
 
-      // Call the middleware with a non-index path
-      await mockMiddleware(
-        {
-          url: "/other",
-          originalUrl: "/other",
-        },
-        mockRes,
-        mockNext,
-      )
+      await mockMiddleware({ url: "/", originalUrl: "/" }, mockRes, mockNext)
+
+      expect(mockRes.statusCode).toBe(0)
+      expect(mockRes.setHeader).not.toHaveBeenCalled()
+      expect(mockRes.end).not.toHaveBeenCalled()
+      expect(mockNext).toHaveBeenCalledTimes(1)
+    })
+
+    it("calls next() for non-root and non-/index.html requests", async () => {
+      await setupServer()
+      mockFs(rootIndexPath)
+
+      await mockMiddleware({ url: "/other/path", originalUrl: "/other/path" }, mockRes, mockNext)
 
-      // Verify the request was passed through
       expect(mockRes.statusCode).toBe(0)
       expect(mockRes.setHeader).not.toHaveBeenCalled()
       expect(mockRes.end).not.toHaveBeenCalled()
-      expect(mockNext).toHaveBeenCalled()
+      expect(mockNext).toHaveBeenCalledTimes(1)
+    })
+
+    it("calls next() for / when autoDetectIndex is false, even if index exists", async () => {
+      await setupServer({ autoDetectIndex: false })
+      mockFs(rootIndexPath)
+
+      await mockMiddleware({ url: "/", originalUrl: "/" }, mockRes, mockNext)
+
+      expect(mockRes.statusCode).toBe(0)
+      expect(mockRes.setHeader).not.toHaveBeenCalled()
+      expect(mockRes.end).not.toHaveBeenCalled()
+      expect(mockNext).toHaveBeenCalledTimes(1)
+    })
+
+    it("serves placeholder for /index.html when autoDetectIndex is false", async () => {
+      const appUrl = "http://test.app:8000"
+      process.env.APP_URL = appUrl // Set env BEFORE setupServer
+      await setupServer({ autoDetectIndex: false })
+      mockFs(null)
+      // No specific readFile mock needed, relies on actual file read via robust dirname
+
+      await mockMiddleware({ url: "/index.html", originalUrl: "/index.html" }, mockRes, mockNext)
+
+      expect(mockRes.statusCode).toBe(200)
+      expect(mockRes.setHeader).toHaveBeenCalledWith("Content-Type", "text/html")
+      // Expect actual content with replaced URL
+      expect(mockRes.end).toHaveBeenCalledWith(actualPlaceholderContent.replace(/{{ APP_URL }}/g, appUrl))
+      expect(mockNext).not.toHaveBeenCalled()
+    })
+
+    it("handles errors during index.html reading", async () => {
+      await setupServer()
+      mockFs(rootIndexPath) // Access mock allows finding the path
+      // No specific readFile mock needed, let actual read fail
+
+      await mockMiddleware({ url: "/", originalUrl: "/" }, mockRes, mockNext)
+
+      // Check for any error and specific code
+      expect(mockNext).toHaveBeenCalledWith(expect.any(Error))
+      expect(mockNext.mock.calls[0][0].code).toBe("ENOENT")
+      expect(mockRes.end).not.toHaveBeenCalled()
+      expect(mockServer.config.logger.error).toHaveBeenCalledWith(expect.stringContaining("Error serving index.html"))
+    })
+
+    it("handles errors during placeholder reading", async () => {
+      await setupServer()
+      mockFs(null) // Access mock prevents finding a path
+      const placeholderError = new Error("Cannot read placeholder")
+      // Specific mock to force placeholder read error
+      vi.spyOn(fs.promises, "readFile").mockRejectedValue(placeholderError)
+
+      await mockMiddleware({ url: "/index.html", originalUrl: "/index.html" }, mockRes, mockNext)
+
+      expect(mockRes.statusCode).toBe(404)
+      expect(mockRes.end).toHaveBeenCalledWith(expect.stringContaining("Error loading placeholder"))
+      expect(mockNext).not.toHaveBeenCalled()
+      expect(mockServer.config.logger.error).toHaveBeenCalledWith(expect.stringContaining("Error serving placeholder index.html"))
     })
   })
 })
+
 describe("inertia-helpers", () => {
   const testPath = "./__data__/dummy.ts"
 
   beforeEach(() => {
     vi.resetModules()
-    // Mock the import.meta.glob functionality
     vi.mock("./__data__/dummy.ts", () => ({
       default: "Dummy File",
     }))
@@ -697,8 +769,7 @@ describe("inertia-helpers", () => {
     const pages = {
       [testPath]: { default: "Dummy File" },
     }
-    // @ts-ignore
-    const file = await resolvePageComponent<{ default: string }>(testPath, pages)
+    const file = await resolvePageComponent<{ default: string }>(testPath, pages as any)
     expect(file.default).toBe("Dummy File")
   })
 
@@ -706,12 +777,7 @@ describe("inertia-helpers", () => {
     const pages = {
       [testPath]: { default: "Dummy File" },
     }
-
-    const file = await resolvePageComponent<{ default: string }>(
-      ["missing-page", testPath],
-      // @ts-ignore
-      pages,
-    )
+    const file = await resolvePageComponent<{ default: string }>(["missing-page", testPath], pages as any)
     expect(file.default).toBe("Dummy File")
   })
 
@@ -773,7 +839,6 @@ describe("inertia-helpers", () => {
 
   describe("currentRoute()", () => {
     beforeEach(() => {
-      // Mock window.location
       Object.defineProperty(window, "location", {
         value: {
           pathname: "/api/users/list",
@@ -812,7 +877,6 @@ describe("inertia-helpers", () => {
 
   describe("isCurrentRoute()", () => {
     beforeEach(() => {
-      // Mock window.location
       Object.defineProperty(window, "location", {
         value: {
           pathname: "/api/users/list",

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/src/py/litestar_vite/cli.py

@@ -168,7 +168,6 @@ def vite_init(
             )
             install_dir = os.environ.get("VIRTUAL_ENV", sys.prefix)
             console.rule("[yellow]Starting Nodeenv installation process[/]", align="left")
-            console.print(f"Installing Node environment into {install_dir}")
             execute_command(command_to_run=[nodeenv_command, install_dir, "--force", "--quiet"], cwd=root_path)
 
         console.rule("[yellow]Starting package installation process[/]", align="left")
@@ -206,7 +205,6 @@ def vite_install(app: "Litestar", verbose: "bool") -> None:
         )
         install_dir = os.environ.get("VIRTUAL_ENV", sys.prefix)
         console.rule("[yellow]Starting Nodeenv installation process[/]", align="left")
-        console.print("Installing Node environment to %s:", install_dir)
         execute_command(command_to_run=[nodeenv_command, install_dir, "--force", "--quiet"], cwd=plugin.config.root_dir)
 
     console.rule("[yellow]Starting package installation process[/]", align="left")

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/src/py/litestar_vite/commands.py

@@ -13,12 +13,12 @@ if TYPE_CHECKING:
 VITE_INIT_TEMPLATES: "set[str]" = {"package.json.j2", "tsconfig.json.j2", "vite.config.ts.j2"}
 DEFAULT_RESOURCES: "set[str]" = {"styles.css.j2", "main.ts.j2"}
 DEFAULT_DEV_DEPENDENCIES: "dict[str, str]" = {
-    "typescript": "^5.7.2",
-    "vite": "^6.0.6",
-    "litestar-vite-plugin": "^0.13.1",
-    "@types/node": "^22.10.2",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "litestar-vite-plugin": "^0.13.2",
+    "@types/node": "^22.15.3",
 }
-DEFAULT_DEPENDENCIES: "dict[str, str]" = {"axios": "^1.7.9"}
+DEFAULT_DEPENDENCIES: "dict[str, str]" = {"axios": "^1.9.0"}
 
 
 def to_json(value: "Any") -> str:

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/src/py/litestar_vite/inertia/config.py

@@ -21,7 +21,7 @@ class InertiaConfig:
     """Optionally supply a path where unauthorized requests should redirect."""
     redirect_404: "Optional[str]" = None
     """Optionally supply a path where 404 requests should redirect."""
-    extra_static_page_props: "dict[str, Any]" = field(default_factory=dict)
+    extra_static_page_props: "dict[str, Any]" = field(default_factory=dict)  # pyright: ignore
     """A dictionary of values to automatically add in to page props on every response."""
-    extra_session_page_props: "set[str]" = field(default_factory=set)
+    extra_session_page_props: "set[str]" = field(default_factory=set)  # pyright: ignore
     """A set of session keys for which the value automatically be added (if it exists) to the response."""

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/src/py/litestar_vite/loader.py

@@ -104,7 +104,9 @@ class ViteAssetLoader(metaclass=SingletonMeta):
         Returns:
             The manifest loader.
         """
-        return cls(config=config)
+        loader = cls(config=config)
+        loader.parse_manifest()
+        return loader
 
     @cached_property
     def version_id(self) -> str:

{litestar_vite-0.13.1 → litestar_vite-0.13.2}/src/py/litestar_vite/plugin.py

@@ -78,7 +78,6 @@ class ViteProcess:
                 if self.process and self.process.poll() is None:  # pyright: ignore[reportUnknownMemberType]
                     return
 
-                console.print(f"Starting Vite process with command: {command}")
                 self.process = subprocess.Popen(
                     command,
                     cwd=cwd,
@@ -104,7 +103,6 @@ class ViteProcess:
                         if hasattr(signal, "SIGKILL"):
                             self.process.kill()  # pyright: ignore[reportUnknownMemberType]
                         self.process.wait(timeout=1.0)  # pyright: ignore[reportUnknownMemberType]
-                console.print("Stopping Vite process")
         except Exception as e:
             console.print(f"[red]Failed to stop Vite process: {e!s}[/]")
             raise
@@ -200,7 +198,8 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
         Yields:
             An iterator of None.
         """
-
+        if self._config.set_environment:
+            set_environment(config=self._config)
         if self._config.use_server_lifespan and self._config.dev_mode:
             command_to_run = self._config.run_command if self._config.hot_reload else self._config.build_watch_command
 
@@ -209,9 +208,6 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
             else:
                 console.rule("[yellow]Starting Vite watch and build process[/]", align="left")
 
-            if self._config.set_environment:
-                set_environment(config=self._config)
-
             try:
                 self._vite_process.start(command_to_run, self._config.root_dir)
                 yield