litestar-vite 0.15.0__py3-none-any.whl → 0.15.0rc2__py3-none-any.whl

litestar_vite/cli.py

@@ -1,4 +1,3 @@
-import contextlib
 import os
 import subprocess
 import sys
@@ -6,6 +5,7 @@ from pathlib import Path
 from textwrap import dedent
 from typing import TYPE_CHECKING, Any
 
+import msgspec
 from click import Choice, Context, group, option
 from click import Path as ClickPath
 from litestar.cli._utils import (  # pyright: ignore[reportPrivateImportUsage]
@@ -14,15 +14,25 @@ from litestar.cli._utils import (  # pyright: ignore[reportPrivateImportUsage]
     LitestarGroup,
     console,
 )
+from litestar.exceptions import SerializationException
+from litestar.serialization import decode_json, encode_json, get_serializer
 from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
 
-from litestar_vite.codegen import encode_deterministic_json, generate_routes_json, generate_routes_ts, write_if_changed
-from litestar_vite.config import DeployConfig, ExternalDevServer, LoggingConfig, TypeGenConfig, ViteConfig
+from litestar_vite.codegen import generate_inertia_pages_json, generate_routes_json, generate_routes_ts
+from litestar_vite.config import (
+    DeployConfig,
+    ExternalDevServer,
+    InertiaConfig,
+    InertiaTypeGenConfig,
+    LoggingConfig,
+    TypeGenConfig,
+    ViteConfig,
+)
 from litestar_vite.deploy import ViteDeployer, format_bytes
 from litestar_vite.doctor import ViteDoctor
 from litestar_vite.exceptions import ViteExecutionError
-from litestar_vite.plugin import VitePlugin, set_environment
+from litestar_vite.plugin import VitePlugin, resolve_litestar_version, set_environment
 from litestar_vite.scaffolding import TemplateContext, generate_project, get_available_templates
 from litestar_vite.scaffolding.templates import FrameworkType, get_template
 
@@ -87,6 +97,19 @@ def _apply_cli_log_level(config: ViteConfig, *, verbose: bool = False, quiet: bo
         config.reset_executor()
 
 
+def _relative_path(path: Path) -> str:
+    """Return path relative to CWD when possible.
+
+    Returns:
+        The relative path string when possible, otherwise the absolute path string.
+    """
+
+    try:
+        return str(path.relative_to(Path.cwd()))
+    except ValueError:
+        return str(path)
+
+
 def _print_recommended_config(template_name: str, resource_dir: str, bundle_dir: str) -> None:
     """Print recommended ViteConfig for the scaffolded template.
 
@@ -185,13 +208,9 @@ def _build_deploy_config(
     return deploy_config
 
 
-def _run_vite_build(
-    config: ViteConfig, root_dir: Path, console: Any, no_build: bool, app: "Litestar | None" = None
-) -> None:
+def _run_vite_build(config: ViteConfig, root_dir: Path, console: Any, no_build: bool) -> None:
     """Run Vite build unless skipped.
 
-    If app is provided, exports schema/routes before building.
-
     Raises:
         SystemExit: If the build fails.
     """
@@ -199,14 +218,10 @@ def _run_vite_build(
         console.print("[dim]Skipping Vite build (--no-build).[/]")
         return
 
-    # Export schema/routes if app is provided
-    if app is not None:
-        _generate_schema_and_routes(app, config, console)
-
     console.rule("[yellow]Starting Vite build process[/]", align="left")
     if config.set_environment:
-        set_environment(config=config, asset_url_override=config.asset_url)
-    os.environ.setdefault("VITE_BASE_URL", config.base_url or "/")
+        set_environment(config=config, asset_url_override=config.base_url or config.asset_url)
+    os.environ["VITE_BASE_URL"] = config.base_url or config.asset_url or "/"
     try:
         config.executor.execute(config.build_command, cwd=root_dir)
         console.print("[bold green]✓ Build complete[/]")
@@ -218,36 +233,52 @@ def _run_vite_build(
 def _generate_schema_and_routes(app: "Litestar", config: ViteConfig, console: Any) -> None:
     """Export OpenAPI schema, routes, and Inertia page props prior to running a build.
 
-    Uses the shared `export_integration_assets` function to guarantee byte-identical
-    output between CLI and Plugin.
-
     Skips generation when type generation is disabled.
 
+    When Inertia page-props export is enabled, the generator may add additional component schemas
+    for routes that are excluded from OpenAPI. In that case, this function persists the augmented
+    OpenAPI document so the TypeScript generator can emit those types.
+
     Raises:
         LitestarCLIException: If export fails.
     """
-    from litestar_vite.codegen import export_integration_assets
-
     types_config = config.types
     if not isinstance(types_config, TypeGenConfig):
         return
 
     console.print("[dim]Preparing OpenAPI schema and routes...[/]")
+    _export_openapi_schema(app, types_config)
+    _export_routes_metadata(app, types_config)
 
-    try:
-        result = export_integration_assets(app, config)
-
-        # Report results with detailed status
-        for file in result.exported_files:
-            console.print(f"[green]✓ Exported {file}[/] [dim](updated)[/]")
-        for file in result.unchanged_files:
-            console.print(f"[dim]✓ {file} (unchanged)[/]")
-
-        if not result.exported_files and not result.unchanged_files:
-            console.print("[yellow]! No files exported (OpenAPI may not be available)[/]")
-    except (OSError, TypeError, ValueError) as exc:
-        msg = f"Failed to export type metadata: {exc}"
-        raise LitestarCLIException(msg) from exc
+    if types_config.generate_routes:
+        console.print("[dim]3. Exporting typed routes...[/]")
+        try:
+            routes_ts_content = generate_routes_ts(app)
+            routes_ts_path = types_config.routes_ts_path or (types_config.output / "routes.ts")
+            routes_ts_path.parent.mkdir(parents=True, exist_ok=True)
+            routes_ts_path.write_text(routes_ts_content, encoding="utf-8")
+            console.print(f"[green]✓ Typed routes exported to {_relative_path(routes_ts_path)}[/]")
+        except OSError as exc:  # pragma: no cover
+            msg = f"Failed to export typed routes: {exc}"
+            raise LitestarCLIException(msg) from exc
+
+    if isinstance(config.inertia, InertiaConfig) and types_config.generate_page_props and types_config.page_props_path:
+        openapi_schema: dict[str, Any] | None = None
+        try:
+            if types_config.openapi_path and types_config.openapi_path.exists():
+                openapi_schema = decode_json(types_config.openapi_path.read_bytes())
+        except (OSError, SerializationException):
+            pass
+
+        _export_inertia_pages_metadata(app, types_config, config.inertia, openapi_schema)
+        if openapi_schema is not None and types_config.openapi_path is not None:
+            try:
+                schema_content = msgspec.json.format(encode_json(openapi_schema), indent=2)
+                types_config.openapi_path.parent.mkdir(parents=True, exist_ok=True)
+                types_config.openapi_path.write_bytes(schema_content)
+            except OSError as exc:  # pragma: no cover
+                msg = f"Failed to update OpenAPI schema: {exc}"
+                raise LitestarCLIException(msg) from exc
 
 
 @group(cls=LitestarGroup, name="assets")
@@ -585,46 +616,6 @@ def vite_install(app: "Litestar", verbose: "bool", quiet: "bool") -> None:
         console.print("[red]Executor not configured.[/]")
 
 
-@vite_group.command(name="update", help="Update frontend packages.")
-@option(
-    "--latest", type=bool, help="Update to latest versions (ignoring semver constraints).", default=False, is_flag=True
-)
-@option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
-@option("--quiet", type=bool, help="Suppress non-essential output.", default=False, is_flag=True)
-def vite_update(app: "Litestar", latest: "bool", verbose: "bool", quiet: "bool") -> None:
-    """Update frontend packages.
-
-    By default, updates packages within their semver constraints defined in package.json.
-    Use --latest to update to the newest versions available.
-
-    Raises:
-        SystemExit: If the update fails.
-    """
-    if verbose:
-        app.debug = True
-
-    plugin = app.plugins.get(VitePlugin)
-
-    _apply_cli_log_level(plugin.config, verbose=verbose, quiet=quiet)
-
-    if not quiet:
-        if latest:
-            console.rule("[yellow]Updating packages to latest versions[/]", align="left")
-        else:
-            console.rule("[yellow]Updating packages[/]", align="left")
-
-    if plugin.config.executor:
-        root_dir = Path(plugin.config.root_dir or Path.cwd())
-        try:
-            plugin.config.executor.update(root_dir, latest=latest)
-            console.print("[bold green]✓ Packages updated[/]")
-        except ViteExecutionError as e:
-            console.print(f"[bold red]✗ Package update failed: {e!s}[/]")
-            raise SystemExit(1) from None
-    else:
-        console.print("[red]Executor not configured.[/]")
-
-
 @vite_group.command(name="build", help="Building frontend assets with Vite.")
 @option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
 @option("--quiet", type=bool, help="Suppress non-essential output.", default=False, is_flag=True)
@@ -710,9 +701,8 @@ def vite_deploy(
 
     root_dir = Path(config.root_dir or Path.cwd())
     bundle_dir = config.bundle_dir
-
     try:
-        _run_vite_build(config, root_dir, console, no_build, app=app)
+        _run_vite_build(config, root_dir, console, no_build)
     except SystemExit as exc:
         console.print(f"[red]{exc}[/]")
         sys.exit(1)
@@ -751,7 +741,7 @@ def vite_deploy(
 
 @vite_group.command(
     name="serve",
-    help="Serve frontend assets. For meta-frameworks (mode='framework'; aliases: 'ssr'/'ssg'), runs production Node server. Otherwise runs Vite dev server.",
+    help="Serve frontend assets. For SSR frameworks (mode='ssr'), runs production Node server. Otherwise runs Vite dev server.",
 )
 @option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
 @option("--quiet", type=bool, help="Suppress non-essential output.", default=False, is_flag=True)
@@ -862,13 +852,12 @@ def export_routes(
 
         console.rule(f"[yellow]Exporting typed routes to {output}[/]", align="left")
 
-        global_route = bool(isinstance(config.types, TypeGenConfig) and config.types.global_route)
-        routes_ts_content = generate_routes_ts(app, only=only_list, exclude=exclude_list, global_route=global_route)
+        routes_ts_content = generate_routes_ts(app, only=only_list, exclude=exclude_list)
 
         try:
-            changed = write_if_changed(output, routes_ts_content)
-            status = "updated" if changed else "unchanged"
-            console.print(f"[green]✓ Typed routes exported to {output}[/] [dim]({status})[/]")
+            output.parent.mkdir(parents=True, exist_ok=True)
+            output.write_text(routes_ts_content, encoding="utf-8")
+            console.print(f"[green]✓ Typed routes exported to {output}[/]")
         except OSError as e:  # pragma: no cover
             msg = f"Failed to write routes to path {output}"
             raise LitestarCLIException(msg) from e
@@ -888,16 +877,125 @@ def export_routes(
         )
 
         try:
-            content = encode_deterministic_json(routes_data)
-            changed = write_if_changed(output, content)
-            status = "updated" if changed else "unchanged"
-            console.print(f"[green]✓ Routes exported to {output}[/] [dim]({status})[/]")
+            content = msgspec.json.format(encode_json(routes_data), indent=2)
+            output.parent.mkdir(parents=True, exist_ok=True)
+            output.write_bytes(content)
+            console.print(f"[green]✓ Routes exported to {output}[/]")
             console.print(f"[dim]  {len(routes_data.get('routes', {}))} routes exported[/]")
         except OSError as e:  # pragma: no cover
             msg = f"Failed to write routes to path {output}"
             raise LitestarCLIException(msg) from e
 
 
+def _export_openapi_schema(app: "Litestar", types_config: Any) -> None:
+    """Export OpenAPI schema to file.
+
+    Args:
+        app: The Litestar application instance.
+        types_config: The TypeGenConfig instance.
+
+    Raises:
+        LitestarCLIException: If export fails.
+    """
+    console.print("[dim]1. Exporting OpenAPI schema...[/]")
+    try:
+        serializer = get_serializer(app.type_encoders)
+        schema_dict = app.openapi_schema.to_schema()
+        schema_content = msgspec.json.format(encode_json(schema_dict, serializer=serializer), indent=2)
+        types_config.openapi_path.parent.mkdir(parents=True, exist_ok=True)
+        types_config.openapi_path.write_bytes(schema_content)
+        console.print(f"[green]✓ Schema exported to {_relative_path(types_config.openapi_path)}[/]")
+    except OSError as e:
+        msg = f"Failed to export OpenAPI schema: {e}"
+        raise LitestarCLIException(msg) from e
+
+
+def _export_routes_metadata(app: "Litestar", types_config: Any) -> None:
+    """Export routes metadata to file.
+
+    Args:
+        app: The Litestar application instance.
+        types_config: The TypeGenConfig instance.
+
+    Raises:
+        LitestarCLIException: If export fails.
+    """
+    console.print("[dim]2. Exporting route metadata...[/]")
+    try:
+        routes_data = generate_routes_json(app, include_components=True)
+        routes_data["litestar_version"] = resolve_litestar_version()
+        routes_content = msgspec.json.format(encode_json(routes_data), indent=2)
+        types_config.routes_path.parent.mkdir(parents=True, exist_ok=True)
+        types_config.routes_path.write_bytes(routes_content)
+        console.print(f"[green]✓ Routes exported to {_relative_path(types_config.routes_path)}[/]")
+    except OSError as e:
+        msg = f"Failed to export routes: {e}"
+        raise LitestarCLIException(msg) from e
+
+
+def _export_routes_typescript(app: "Litestar", types_config: Any) -> None:
+    """Export typed routes TypeScript file (Ziggy-style).
+
+    Args:
+        app: The Litestar application instance.
+        types_config: The TypeGenConfig instance.
+
+    Raises:
+        LitestarCLIException: If export fails.
+    """
+    if not types_config.generate_routes:
+        return
+
+    console.print("[dim]   Generating typed routes.ts...[/]")
+    try:
+        ts_content = generate_routes_ts(app)
+        types_config.routes_ts_path.parent.mkdir(parents=True, exist_ok=True)
+        types_config.routes_ts_path.write_text(ts_content)
+        console.print(f"[green]✓ Typed routes generated at {_relative_path(types_config.routes_ts_path)}[/]")
+    except OSError as e:
+        msg = f"Failed to generate typed routes: {e}"
+        raise LitestarCLIException(msg) from e
+
+
+def _export_inertia_pages_metadata(
+    app: "Litestar", types_config: Any, inertia_config: Any, openapi_schema: "dict[str, Any] | None" = None
+) -> None:
+    """Export Inertia page props metadata to file.
+
+    Args:
+        app: The Litestar application instance.
+        types_config: The TypeGenConfig instance.
+        inertia_config: The InertiaConfig instance.
+        openapi_schema: Optional pre-loaded OpenAPI schema.
+
+    Raises:
+        LitestarCLIException: If export fails.
+    """
+    console.print("[dim]4. Exporting Inertia page props metadata...[/]")
+    inertia_type_gen = inertia_config.type_gen
+    if inertia_type_gen is None:
+        inertia_type_gen = InertiaTypeGenConfig()
+
+    try:
+        pages_data = generate_inertia_pages_json(
+            app,
+            openapi_schema=openapi_schema,
+            include_default_auth=inertia_type_gen.include_default_auth,
+            include_default_flash=inertia_type_gen.include_default_flash,
+            inertia_config=inertia_config,
+            types_config=types_config,
+        )
+        pages_content = msgspec.json.format(encode_json(pages_data), indent=2)
+        types_config.page_props_path.parent.mkdir(parents=True, exist_ok=True)
+        types_config.page_props_path.write_bytes(pages_content)
+        num_pages = len(pages_data.get("pages", {}))
+        console.print(f"[green]✓ Page props exported to {_relative_path(types_config.page_props_path)}[/]")
+        console.print(f"[dim]  {num_pages} Inertia page(s) found[/]")
+    except OSError as e:
+        msg = f"Failed to export Inertia page props: {e}"
+        raise LitestarCLIException(msg) from e
+
+
 def _get_package_executor_cmd(executor: "str | None", package: str) -> "list[str]":
     """Build package executor command list.
 
@@ -924,43 +1022,67 @@ def _get_package_executor_cmd(executor: "str | None", package: str) -> "list[str
             return ["npx", package]
 
 
-def _invoke_typegen_cli(config: Any, verbose: bool) -> None:
-    """Invoke the unified TypeScript type generation CLI.
-
-    This is the single entry point for TypeScript type generation, used by
-    `litestar assets generate-types`. It calls `litestar-vite-typegen` which
-    handles both @hey-api/openapi-ts and page-props.ts generation.
+def _run_openapi_ts(
+    config: Any, verbose: bool, install_command: "list[str] | None" = None, executor: "str | None" = None
+) -> None:
+    """Run @hey-api/openapi-ts to generate TypeScript types.
 
     Args:
         config: The ViteConfig instance (with .types resolved).
         verbose: Whether to show verbose output.
-
-    Raises:
-        LitestarCLIException: If type generation fails.
+        install_command: Command used to install JS dependencies.
+        executor: The JS runtime executor (node, bun, deno, yarn, pnpm).
     """
+    types_config = config.types
     root_dir = config.root_dir or Path.cwd()
-    executor = config.runtime.executor
+    resource_dir = Path(config.resource_dir)
+    if not resource_dir.is_absolute():
+        resource_dir = root_dir / resource_dir
 
-    # Build the command to run the unified TypeScript CLI
-    pkg_cmd = _get_package_executor_cmd(executor, "litestar-vite-typegen")
-    cmd = [*pkg_cmd]
+    console.print("[dim]3. Running @hey-api/openapi-ts...[/]")
 
-    if verbose:
-        cmd.append("--verbose")
+    install_cmd = install_command or ["npm", "install"]
+    pkg_cmd = _get_package_executor_cmd(executor, "@hey-api/openapi-ts")
 
     try:
-        # Run the CLI, letting stdout/stderr pass through to the terminal
-        result = subprocess.run(cmd, cwd=root_dir, check=False)
-        if result.returncode != 0:
-            msg = "TypeScript type generation failed"
-            raise LitestarCLIException(msg)
+        check_cmd = [*pkg_cmd, "--version"]
+        subprocess.run(check_cmd, check=True, capture_output=True, cwd=root_dir)
+
+        candidate_configs = [
+            resource_dir / "openapi-ts.config.ts",
+            resource_dir / "hey-api.config.ts",
+            root_dir / "openapi-ts.config.ts",
+            root_dir / "hey-api.config.ts",
+        ]
+        config_path = next((p for p in candidate_configs if p.exists()), None)
+
+        if config_path is not None:
+            openapi_cmd = [*pkg_cmd, "--file", str(config_path)]
+        else:
+            openapi_cmd = [*pkg_cmd, "-i", str(types_config.openapi_path), "-o", str(types_config.output)]
+
+            plugins: list[str] = ["@hey-api/typescript", "@hey-api/schemas"]
+            if types_config.generate_sdk:
+                plugins.extend(["@hey-api/sdk"])
+            if types_config.generate_zod:
+                plugins.append("zod")
+
+            if plugins:
+                openapi_cmd.extend(["--plugins", *plugins])
+
+        subprocess.run(openapi_cmd, check=True, cwd=root_dir)
+        console.print(f"[green]✓ Types generated in {types_config.output}[/]")
+    except subprocess.CalledProcessError as e:
+        console.print("[yellow]! @hey-api/openapi-ts failed - install it with:[/]")
+        extra = ["@hey-api/openapi-ts"]
+        if types_config.generate_zod:
+            extra.append("zod")
+        console.print(f"[dim]  {' '.join([*install_cmd, '-D', *extra])}[/]")
+        if verbose:
+            console.print(f"[dim]Error: {e!s}[/]")
     except FileNotFoundError:
         runtime_name = executor or "Node.js"
-        console.print(
-            f"[yellow]! litestar-vite-typegen not found - ensure {runtime_name} and litestar-vite-plugin are installed[/]"
-        )
-        msg = f"Package executor not found - ensure {runtime_name} is installed"
-        raise LitestarCLIException(msg) from None
+        console.print(f"[yellow]! Package executor not found - ensure {runtime_name} is installed[/]")
 
 
 @vite_group.command(name="generate-types", help="Generate TypeScript types from OpenAPI schema and routes.")
@@ -968,22 +1090,16 @@ def _invoke_typegen_cli(config: Any, verbose: bool) -> None:
 def generate_types(app: "Litestar", verbose: "bool") -> None:
     """Generate TypeScript types from OpenAPI schema and routes.
 
-    Uses the unified TypeScript CLI (litestar-vite-typegen) to ensure
-    identical output between CLI, dev server, and build commands.
-
     This command:
-    1. Exports OpenAPI schema, routes, and page props metadata
-    2. Invokes the unified TypeScript CLI which handles:
-       - @hey-api/openapi-ts for API types
-       - page-props.ts for Inertia page props (if enabled)
+    1. Exports the OpenAPI schema (uses litestar's built-in schema generation)
+    2. Exports route metadata
+    3. Runs @hey-api/openapi-ts to generate TypeScript types
+    4. If Inertia is enabled: exports page props metadata
 
     Args:
         app: The Litestar application instance.
         verbose: Whether to enable verbose output.
     """
-    from litestar_vite.codegen import export_integration_assets
-    from litestar_vite.plugin._utils import write_runtime_config_file
-
     if verbose:
         app.debug = True
 
@@ -997,35 +1113,20 @@ def generate_types(app: "Litestar", verbose: "bool") -> None:
 
     console.rule("[yellow]Generating TypeScript types[/]", align="left")
 
-    config_path, config_changed = write_runtime_config_file(config, return_status=True)
-    config_display = Path(config_path)
-    with contextlib.suppress(ValueError):
-        config_display = config_display.relative_to(Path.cwd())
-    if config_changed:
-        console.print(f"[green]✓ Exported {config_display}[/] [dim](updated)[/]")
-    else:
-        console.print(f"[dim]✓ {config_display} (unchanged)[/]")
-
-    # Export all integration assets using the shared function
-    try:
-        result = export_integration_assets(app, config)
-
-        # Report results with detailed status
-        for file in result.exported_files:
-            console.print(f"[green]✓ Exported {file}[/] [dim](updated)[/]")
-        for file in result.unchanged_files:
-            console.print(f"[dim]✓ {file} (unchanged)[/]")
-
-        if not result.exported_files and not result.unchanged_files:
-            console.print("[yellow]! No files exported (OpenAPI may not be available)[/]")
-            return
-    except (OSError, TypeError, ValueError) as exc:
-        console.print(f"[red]✗ Failed to export type metadata: {exc}[/]")
-        return
+    _export_openapi_schema(app, config.types)
+    _export_routes_metadata(app, config.types)
+    _export_routes_typescript(app, config.types)
+    _run_openapi_ts(config, verbose, config.install_command, config.runtime.executor)
+    if isinstance(config.inertia, InertiaConfig) and config.types.generate_page_props and config.types.page_props_path:
+        openapi_schema: dict[str, Any] | None = None
+        try:
+            if config.types.openapi_path and config.types.openapi_path.exists():
+                openapi_schema = decode_json(config.types.openapi_path.read_bytes())
+        except (OSError, SerializationException):
+            if verbose:
+                console.print("[dim]! Could not load OpenAPI schema for type references[/]")
 
-    # Invoke the unified TypeScript type generation CLI
-    # This handles both @hey-api/openapi-ts and page-props.ts generation
-    _invoke_typegen_cli(config, verbose)
+        _export_inertia_pages_metadata(app, config.types, config.inertia, openapi_schema)
 
 
 @vite_group.command(name="status", help="Check the status of the Vite integration.")
@@ -1042,13 +1143,11 @@ def vite_status(app: "Litestar") -> None:
     console.print(f"Assets URL: {config.asset_url}")
     console.print(f"Base URL: {config.base_url}")
 
-    manifest_candidates = config.candidate_manifest_paths()
-    found_manifest = next((path for path in manifest_candidates if path.exists()), None)
-    if found_manifest is not None:
-        console.print(f"[green]✓ Manifest found at {found_manifest}[/]")
+    manifest_path = Path(f"{config.bundle_dir}/{config.manifest_name}")
+    if manifest_path.exists():
+        console.print(f"[green]✓ Manifest found at {manifest_path}[/]")
     else:
-        manifest_locations = " or ".join(str(path) for path in manifest_candidates)
-        console.print(f"[red]✗ Manifest not found at {manifest_locations}[/]")
+        console.print(f"[red]✗ Manifest not found at {manifest_path}[/]")
 
     if config.dev_mode:
         url = f"{config.protocol}://{config.host}:{config.port}"

litestar_vite/codegen.py

@@ -0,0 +1,39 @@
+"""Public code generation API.
+
+The internal implementation lives in ``litestar_vite._codegen``.
+
+This module provides a stable import surface for:
+
+- Route metadata export (``routes.json`` + Ziggy-compatible TS)
+- Inertia page props metadata export
+"""
+
+from litestar_vite._codegen.inertia import (  # noqa: F401
+    InertiaPageMetadata,
+    _get_openapi_schema_ref,  # pyright: ignore[reportPrivateUsage,reportUnusedImport]
+    _get_return_type_name,  # pyright: ignore[reportPrivateUsage,reportUnusedImport]
+    extract_inertia_pages,
+    generate_inertia_pages_json,
+)
+from litestar_vite._codegen.routes import (  # noqa: F401
+    RouteMetadata,
+    _escape_ts_string,  # pyright: ignore[reportPrivateUsage,reportUnusedImport]
+    _is_type_required,  # pyright: ignore[reportPrivateUsage,reportUnusedImport]
+    _ts_type_for_param,  # pyright: ignore[reportPrivateUsage,reportUnusedImport]
+    extract_route_metadata,
+    generate_routes_json,
+    generate_routes_ts,
+)
+from litestar_vite._codegen.ts import (
+    ts_type_from_openapi as _ts_type_from_openapi,  # noqa: F401  # pyright: ignore[reportUnusedImport]
+)
+
+__all__ = (
+    "InertiaPageMetadata",
+    "RouteMetadata",
+    "extract_inertia_pages",
+    "extract_route_metadata",
+    "generate_inertia_pages_json",
+    "generate_routes_json",
+    "generate_routes_ts",
+)

litestar_vite/commands.py

@@ -12,8 +12,11 @@ from litestar_vite.exceptions import MissingDependencyError
 if TYPE_CHECKING:
     from pathlib import Path
 
+    from litestar import Litestar
+
 
 def init_vite(
+    app: "Litestar",
     root_path: "Path",
     resource_path: "Path",
     asset_url: "str",
@@ -21,12 +24,14 @@ def init_vite(
     bundle_path: "Path",
     enable_ssr: "bool",
     vite_port: int,
+    hot_file: "Path",
     litestar_port: int,
     framework: str = "react",
 ) -> None:
     """Initialize a new Vite project using the scaffolding system.
 
     Args:
+        app: The Litestar application instance.
         root_path: Root directory for the Vite project.
         resource_path: Directory containing source files.
         asset_url: Base URL for serving assets.
@@ -34,6 +39,7 @@ def init_vite(
         bundle_path: Output directory for built files.
         enable_ssr: Enable server-side rendering.
         vite_port: Port for Vite dev server.
+        hot_file: Path to hot reload manifest.
         litestar_port: Port for Litestar server.
         framework: Framework template to use (default: react).