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

litestar_vite/{codegen/_routes.py → _codegen/routes.py}

@@ -14,36 +14,10 @@ from litestar._openapi.parameters import (  # pyright: ignore[reportPrivateUsage
 from litestar.handlers import HTTPRouteHandler
 from litestar.routes import HTTPRoute
 
-from litestar_vite.codegen._ts import normalize_path, ts_type_from_openapi
+from litestar_vite._codegen.ts import normalize_path, ts_type_from_openapi
 
 _PATH_PARAM_EXTRACT_PATTERN = re.compile(r"\{([^:}]+)(?::([^}]+))?\}")
 
-# HTTP methods in priority order for Inertia router integration
-_HTTP_METHOD_PRIORITY = ["GET", "POST", "PUT", "PATCH", "DELETE"]
-
-
-def pick_primary_method(methods: list[str]) -> str:
-    """Pick the primary HTTP method for Inertia router integration.
-
-    When a route supports multiple HTTP methods, this picks the most
-    appropriate one for use with Inertia's router.visit() and form.submit().
-
-    Args:
-        methods: List of HTTP methods (e.g., ["GET", "HEAD", "OPTIONS"]).
-
-    Returns:
-        The primary method in lowercase (e.g., "get", "post").
-    """
-    for preferred in _HTTP_METHOD_PRIORITY:
-        if preferred in methods:
-            return preferred.lower()
-    # Fallback to first non-HEAD/OPTIONS method, or "get" if none
-    for method in methods:
-        if method not in {"HEAD", "OPTIONS"}:
-            return method.lower()
-    return "get"
-
-
 _TS_SEMANTIC_ALIASES: dict[str, tuple[str, str]] = {
     "UUID": ("UUID v4 string", "string"),
     "DateTime": ("RFC 3339 date-time string", "string"),
@@ -57,7 +31,7 @@ _TS_SEMANTIC_ALIASES: dict[str, tuple[str, str]] = {
 }
 
 
-def str_dict_factory() -> dict[str, str]:
+def _str_dict_factory() -> dict[str, str]:
     """Return an empty ``dict[str, str]`` (typed for pyright).
 
     Returns:
@@ -73,13 +47,12 @@ class RouteMetadata:
     name: str
     path: str
     methods: list[str]
-    method: str  # Primary method for Inertia router (lowercase)
-    params: dict[str, str] = field(default_factory=str_dict_factory)
-    query_params: dict[str, str] = field(default_factory=str_dict_factory)
+    params: dict[str, str] = field(default_factory=_str_dict_factory)
+    query_params: dict[str, str] = field(default_factory=_str_dict_factory)
     component: "str | None" = None
 
 
-def extract_path_params(path: str) -> dict[str, str]:
+def _extract_path_params(path: str) -> dict[str, str]:
     """Extract path parameters and their types from a route.
 
     Args:
@@ -91,28 +64,22 @@ def extract_path_params(path: str) -> dict[str, str]:
     return {match.group(1): "string" for match in _PATH_PARAM_EXTRACT_PATTERN.finditer(path)}
 
 
-def iter_route_handlers(app: Litestar) -> Generator[tuple["HTTPRoute", HTTPRouteHandler], None, None]:
+def _iter_route_handlers(app: Litestar) -> Generator[tuple["HTTPRoute", HTTPRouteHandler], None, None]:
     """Iterate over HTTP route handlers in an app.
 
-    Returns handlers in deterministic order, sorted by (route_path, handler_name)
-    to ensure consistent output across multiple runs.
-
     Args:
         app: The Litestar application.
 
     Yields:
-        Tuples of (HTTPRoute, HTTPRouteHandler), sorted for determinism.
+        Tuples of (HTTPRoute, HTTPRouteHandler).
     """
-    handlers: list[tuple[HTTPRoute, HTTPRouteHandler]] = []
     for route in app.routes:
         if isinstance(route, HTTPRoute):
-            handlers.extend((route, route_handler) for route_handler in route.route_handlers)
-    # Sort by route path, then handler name for deterministic ordering
-    handlers.sort(key=lambda x: (str(x[0].path), x[1].handler_name or x[1].name or ""))
-    yield from handlers
+            for route_handler in route.route_handlers:
+                yield route, route_handler
 
 
-def extract_params_from_litestar(
+def _extract_params_from_litestar(
     handler: HTTPRouteHandler, http_route: "HTTPRoute", openapi_context: OpenAPIContext | None
 ) -> tuple[dict[str, str], dict[str, str]]:
     """Extract path and query parameters using Litestar's native OpenAPI generation.
@@ -159,7 +126,7 @@ def extract_params_from_litestar(
     return path_params, query_params
 
 
-def make_unique_name(base_name: str, used_names: set[str], path: str, methods: list[str]) -> str:
+def _make_unique_name(base_name: str, used_names: set[str], path: str, methods: list[str]) -> str:
     """Generate a unique route name, avoiding collisions.
 
     Returns:
@@ -210,7 +177,7 @@ def extract_route_metadata(
         with contextlib.suppress(AttributeError, TypeError, ValueError):
             openapi_context = OpenAPIContext(openapi_config=app.openapi_config, plugins=app.plugins.openapi)
 
-    for http_route, route_handler in iter_route_handlers(app):
+    for http_route, route_handler in _iter_route_handlers(app):
         base_name = route_handler.name or route_handler.handler_name or str(route_handler)
         methods = [method.upper() for method in route_handler.http_methods]
 
@@ -231,7 +198,7 @@ def extract_route_metadata(
             else:
                 continue
 
-        route_name = make_unique_name(base_name, used_names, full_path, methods)
+        route_name = _make_unique_name(base_name, used_names, full_path, methods)
         used_names.add(route_name)
 
         if only and not any(pattern in route_name or pattern in full_path for pattern in only):
@@ -239,10 +206,10 @@ def extract_route_metadata(
         if exclude and any(pattern in route_name or pattern in full_path for pattern in exclude):
             continue
 
-        params, query_params = extract_params_from_litestar(route_handler, http_route, openapi_context)
+        params, query_params = _extract_params_from_litestar(route_handler, http_route, openapi_context)
 
         if not params:
-            params = extract_path_params(full_path)
+            params = _extract_path_params(full_path)
 
         normalized_path = normalize_path(full_path)
 
@@ -254,7 +221,6 @@ def extract_route_metadata(
                 name=route_name,
                 path=normalized_path,
                 methods=methods,
-                method=pick_primary_method(methods),
                 params=params,
                 query_params=query_params,
                 component=cast("str | None", component),
@@ -274,31 +240,22 @@ def generate_routes_json(
 ) -> dict[str, Any]:
     """Generate Ziggy-compatible routes JSON.
 
-    The output is deterministic: routes are sorted by name to produce
-    byte-identical output for the same input data.
-
     Returns:
-        A Ziggy-compatible routes payload as a dictionary with sorted keys.
+        A Ziggy-compatible routes payload as a dictionary.
     """
     routes_metadata = extract_route_metadata(app, only=only, exclude=exclude, openapi_schema=openapi_schema)
 
-    # Sort routes by name for deterministic output
-    sorted_routes = sorted(routes_metadata, key=lambda r: r.name)
-
     routes_dict: dict[str, Any] = {}
 
-    for route in sorted_routes:
-        route_data: dict[str, Any] = {"uri": route.path, "methods": route.methods, "method": route.method}
+    for route in routes_metadata:
+        route_data: dict[str, Any] = {"uri": route.path, "methods": route.methods}
 
         if route.params:
-            # Sort params dict for deterministic output
-            sorted_params = dict(sorted(route.params.items()))
-            route_data["parameters"] = list(sorted_params.keys())
-            route_data["parameterTypes"] = sorted_params
+            route_data["parameters"] = list(route.params.keys())
+            route_data["parameterTypes"] = route.params
 
         if route.query_params:
-            # Sort query params for deterministic output
-            route_data["queryParameters"] = dict(sorted(route.query_params.items()))
+            route_data["queryParameters"] = route.query_params
 
         if include_components and route.component:
             route_data["component"] = route.component
@@ -330,7 +287,7 @@ _TS_TYPE_MAP: dict[str, str] = {
 }
 
 
-def ts_type_for_param(param_type: str) -> str:
+def _ts_type_for_param(param_type: str) -> str:
     """Map a parameter type string to TypeScript type.
 
     Returns:
@@ -346,7 +303,7 @@ def ts_type_for_param(param_type: str) -> str:
     return ts_type
 
 
-def is_type_required(param_type: str) -> bool:
+def _is_type_required(param_type: str) -> bool:
     """Check if a parameter type indicates a required field.
 
     Returns:
@@ -355,7 +312,7 @@ def is_type_required(param_type: str) -> bool:
     return "undefined" not in param_type and not param_type.endswith("?")
 
 
-def escape_ts_string(s: str) -> str:
+def _escape_ts_string(s: str) -> str:
     """Escape a string for use in TypeScript string literals.
 
     Returns:
@@ -370,53 +327,42 @@ def generate_routes_ts(
     only: "list[str] | None" = None,
     exclude: "list[str] | None" = None,
     openapi_schema: dict[str, Any] | None = None,
-    global_route: bool = False,
 ) -> str:
     """Generate typed routes TypeScript file (Ziggy-style).
 
-    The output is deterministic: routes are sorted by name to produce
-    byte-identical output for the same input data.
-
     Returns:
         The generated TypeScript source.
     """
     routes_metadata = extract_route_metadata(app, only=only, exclude=exclude, openapi_schema=openapi_schema)
 
-    # Sort routes by name for deterministic output
-    sorted_routes = sorted(routes_metadata, key=lambda r: r.name)
-
     route_names: list[str] = []
     path_params_entries: list[str] = []
     query_params_entries: list[str] = []
     routes_entries: list[str] = []
     used_aliases: set[str] = set()
 
-    for route in sorted_routes:
+    for route in routes_metadata:
         route_name = route.name
         route_names.append(route_name)
 
-        # Sort params for deterministic output
-        sorted_params = dict(sorted(route.params.items())) if route.params else {}
-        sorted_query_params = dict(sorted(route.query_params.items())) if route.query_params else {}
-
-        if sorted_params:
+        if route.params:
             param_fields: list[str] = []
-            for param_name, param_type in sorted_params.items():
-                ts_type = ts_type_for_param(param_type)
+            for param_name, param_type in route.params.items():
+                ts_type = _ts_type_for_param(param_type)
                 ts_type_clean = ts_type.replace(" | undefined", "")
-                used_aliases.update(collect_semantic_aliases(ts_type_clean))
+                used_aliases.update(_collect_semantic_aliases(ts_type_clean))
                 param_fields.append(f"    {param_name}: {ts_type_clean};")
             path_params_entries.append(f"  '{route_name}': {{\n" + "\n".join(param_fields) + "\n  };")
         else:
             path_params_entries.append(f"  '{route_name}': Record<string, never>;")
 
-        if sorted_query_params:
+        if route.query_params:
             query_param_fields: list[str] = []
-            for param_name, param_type in sorted_query_params.items():
-                ts_type = ts_type_for_param(param_type)
-                is_required = is_type_required(param_type)
+            for param_name, param_type in route.query_params.items():
+                ts_type = _ts_type_for_param(param_type)
+                is_required = _is_type_required(param_type)
                 ts_type_clean = ts_type.replace(" | undefined", "")
-                used_aliases.update(collect_semantic_aliases(ts_type_clean))
+                used_aliases.update(_collect_semantic_aliases(ts_type_clean))
                 if is_required:
                     query_param_fields.append(f"    {param_name}: {ts_type_clean};")
                 else:
@@ -425,37 +371,27 @@ def generate_routes_ts(
         else:
             query_params_entries.append(f"  '{route_name}': Record<string, never>;")
 
-        methods_str = ", ".join(f"'{m}'" for m in sorted(route.methods))
+        methods_str = ", ".join(f"'{m}'" for m in route.methods)
         route_entry_lines = [
             f"  '{route_name}': {{",
-            f"    path: '{escape_ts_string(route.path)}',",
+            f"    path: '{_escape_ts_string(route.path)}',",
             f"    methods: [{methods_str}] as const,",
-            f"    method: '{route.method}',",
         ]
-        param_names_str = ", ".join(f"'{p}'" for p in sorted_params) if sorted_params else ""
+        param_names_str = ", ".join(f"'{p}'" for p in route.params) if route.params else ""
         route_entry_lines.append(f"    pathParams: [{param_names_str}] as const,")
 
-        query_names_str = ", ".join(f"'{p}'" for p in sorted_query_params) if sorted_query_params else ""
+        query_names_str = ", ".join(f"'{p}'" for p in route.query_params) if route.query_params else ""
         route_entry_lines.append(f"    queryParams: [{query_names_str}] as const,")
         if route.component:
-            route_entry_lines.append(f"    component: '{escape_ts_string(route.component)}',")
+            route_entry_lines.append(f"    component: '{_escape_ts_string(route.component)}',")
         route_entry_lines.append("  },")
         routes_entries.append("\n".join(route_entry_lines))
 
     route_names_union = "\n  | ".join(f"'{name}'" for name in route_names) if route_names else "never"
 
-    alias_block = render_semantic_aliases(used_aliases)
+    alias_block = _render_semantic_aliases(used_aliases)
     alias_preamble = f"{alias_block}\n\n" if alias_block else ""
 
-    global_route_snippet = ""
-    if global_route:
-        global_route_snippet = (
-            "\n\n// Optionally register route() on window for global access\n"
-            "if (typeof window !== 'undefined') {\n"
-            "  (window as any).route = route;\n"
-            "}\n"
-        )
-
     return f"""// AUTO-GENERATED by litestar-vite. Do not edit.
 /* eslint-disable */
 
@@ -521,9 +457,6 @@ type RoutesWithoutRequiredParams = Exclude<RouteName, RoutesWithRequiredParams>;
  * route('books')                              // '/api/books'
  * route('book_detail', {{ book_id: 123 }})      // '/api/books/123'
  * route('search', {{ q: 'test', limit: 5 }})    // '/api/search?q=test&limit=5'
- *
- * // Access HTTP method from route definition when needed:
- * routeDefinitions.login.method               // 'post'
  */
 export function route<T extends RoutesWithoutRequiredParams>(name: T): string;
 export function route<T extends RoutesWithoutRequiredParams>(
@@ -702,14 +635,14 @@ export function isCurrentRoute(pattern: string): boolean {{
   const regex = new RegExp(`^${{escaped.replace(/\\*/g, '.*')}}$`);
   return regex.test(current);
 }}
-{global_route_snippet}"""
+"""
 
 
-def collect_semantic_aliases(type_expr: str) -> set[str]:
+def _collect_semantic_aliases(type_expr: str) -> set[str]:
     return {alias for alias in _TS_SEMANTIC_ALIASES if alias in type_expr}
 
 
-def render_semantic_aliases(aliases: set[str]) -> str:
+def _render_semantic_aliases(aliases: set[str]) -> str:
     if not aliases:
         return ""
 

litestar_vite/{codegen/_ts.py → _codegen/ts.py}

@@ -56,31 +56,31 @@ def ts_type_from_openapi(schema_dict: dict[str, Any]) -> str:
 
     if "anyOf" in schema_dict and isinstance(schema_dict["anyOf"], list) and schema_dict["anyOf"]:
         schemas = cast("list[Any]", schema_dict["anyOf"])
-        union = {ts_type_from_subschema(s) for s in schemas}
-        return join_union(union)
+        union = {_ts_type_from_subschema(s) for s in schemas}
+        return _join_union(union)
 
     result = "any"
     match schema_dict:
         case {"const": const} if const is not None:
-            result = "any" if const is False else ts_literal(const)
+            result = "any" if const is False else _ts_literal(const)
         case {"enum": enum} if isinstance(enum, list) and enum:
             enum_values = cast("list[Any]", enum)
-            result = " | ".join(ts_literal(v) for v in enum_values)
+            result = " | ".join(_ts_literal(v) for v in enum_values)
         case {"oneOf": one_of} if isinstance(one_of, list) and one_of:
             schemas = cast("list[Any]", one_of)
-            union = {ts_type_from_subschema(s) for s in schemas}
-            result = join_union(union)
+            union = {_ts_type_from_subschema(s) for s in schemas}
+            result = _join_union(union)
         case {"allOf": all_of} if isinstance(all_of, list) and all_of:
             schemas = cast("list[Any]", all_of)
-            parts = [wrap_union_for_intersection(ts_type_from_subschema(s)) for s in schemas]
+            parts = [_wrap_union_for_intersection(_ts_type_from_subschema(s)) for s in schemas]
             parts = [p for p in parts if p and p != "any"]
             result = " & ".join(parts) if parts else "any"
         case {"type": list()}:
             type_entries_list: list[Any] = schema_dict["type"]
-            parts = [ts_type_from_openapi_type_entry(t, schema_dict) for t in type_entries_list if isinstance(t, str)]
-            result = join_union(set(parts)) if parts else "any"
+            parts = [_ts_type_from_openapi_type_entry(t, schema_dict) for t in type_entries_list if isinstance(t, str)]
+            result = _join_union(set(parts)) if parts else "any"
         case {"type": str() as schema_type}:
-            result = ts_type_from_openapi_type_entry(schema_type, schema_dict)
+            result = _ts_type_from_openapi_type_entry(schema_type, schema_dict)
         case _:
             pass
 
@@ -146,13 +146,13 @@ def collect_ref_names(schema_dict: Any) -> set[str]:
     return refs
 
 
-def ts_type_from_subschema(schema: Any) -> str:
+def _ts_type_from_subschema(schema: Any) -> str:
     if isinstance(schema, dict):
         return ts_type_from_openapi(cast("dict[str, Any]", schema))
     return "any"
 
 
-def ts_type_from_openapi_type_entry(type_name: str, schema_dict: dict[str, Any]) -> str:
+def _ts_type_from_openapi_type_entry(type_name: str, schema_dict: dict[str, Any]) -> str:
     primitive_types: dict[str, str] = {
         "string": "string",
         "integer": "number",
@@ -168,8 +168,8 @@ def ts_type_from_openapi_type_entry(type_name: str, schema_dict: dict[str, Any])
             result = _OPENAPI_STRING_FORMAT_TO_TS_ALIAS.get(fmt, result)
     if type_name == "array":
         items = schema_dict.get("items")
-        item_type = ts_type_from_subschema(items) if isinstance(items, dict) else "unknown"
-        result = f"{wrap_for_array(item_type)}[]"
+        item_type = _ts_type_from_subschema(items) if isinstance(items, dict) else "unknown"
+        result = f"{_wrap_for_array(item_type)}[]"
     elif type_name == "object":
         properties = schema_dict.get("properties")
         if not isinstance(properties, dict) or not properties:
@@ -182,7 +182,7 @@ def ts_type_from_openapi_type_entry(type_name: str, schema_dict: dict[str, Any])
 
             lines: list[str] = ["{"]
             for name, prop_schema in cast("dict[str, Any]", properties).items():
-                ts_type = ts_type_from_subschema(prop_schema)
+                ts_type = _ts_type_from_subschema(prop_schema)
                 optional = "" if name in required else "?"
                 lines.append(f"  {name}{optional}: {ts_type};")
             lines.append("}")
@@ -191,7 +191,7 @@ def ts_type_from_openapi_type_entry(type_name: str, schema_dict: dict[str, Any])
     return result
 
 
-def wrap_for_array(type_expr: str) -> str:
+def _wrap_for_array(type_expr: str) -> str:
     expr = type_expr.strip()
     if not expr:
         return "unknown"
@@ -203,7 +203,7 @@ def wrap_for_array(type_expr: str) -> str:
     return expr
 
 
-def wrap_union_for_intersection(type_expr: str) -> str:
+def _wrap_union_for_intersection(type_expr: str) -> str:
     expr = type_expr.strip()
     if not expr:
         return "any"
@@ -214,7 +214,7 @@ def wrap_union_for_intersection(type_expr: str) -> str:
     return expr
 
 
-def join_union(types: set[str]) -> str:
+def _join_union(types: set[str]) -> str:
     if not types:
         return "any"
     if len(types) == 1:
@@ -222,7 +222,7 @@ def join_union(types: set[str]) -> str:
     return " | ".join(sorted(types))
 
 
-def ts_literal(value: Any) -> str:
+def _ts_literal(value: Any) -> str:
     if value is None:
         return "null"
     if isinstance(value, bool):

litestar_vite/_handler/__init__.py

@@ -0,0 +1,8 @@
+"""Internal SPA handler implementation.
+
+The public API is exposed via :mod:`litestar_vite.handler`.
+"""
+
+from litestar_vite._handler.app import AppHandler
+
+__all__ = ("AppHandler",)