datasette-plugin-router 0.0.1a2__py3-none-any.whl

datasette_plugin_router/__init__.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+import inspect
+import re
+from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, get_args, get_origin, Annotated
+from dataclasses import dataclass
+
+
+@dataclass
+class Route:
+    path: str
+    method: str
+    fn: Optional[Callable]
+    output: Optional[type]
+    input_schema: Optional[Dict[str, Any]] = None
+    output_schema: Optional[Dict[str, Any]] = None
+
+T = TypeVar('T')
+
+
+class Body:
+    """Marker for request body parameters.
+
+    Usage:
+      from typing import Annotated
+      
+      async def view(params: Annotated[InputModel, Body()]):
+          # params is properly typed as InputModel
+          # and at runtime, Body() marker tells router to parse request body
+
+    The recommended pattern is to use typing.Annotated for full type safety.
+    For backwards compatibility, Body[Model] syntax is still supported.
+    """
+
+    def __init__(self, model: Optional[type[T]] = None):
+        self.model = model
+
+    def __repr__(self) -> str:  # helpful for debugging
+        if self.model:
+            try:
+                name = getattr(self.model, "__name__", repr(self.model))
+            except Exception:
+                name = repr(self.model)
+            return f"Body[{name}]"
+        return "Body()"
+
+    @classmethod
+    def __class_getitem__(cls, item: type[T]) -> "Body":
+        """Allow writing `Body[Model]` in annotations (backwards compatibility).
+
+        Python will call this at import-time for subscription expressions
+        (PEP 560). We return an instance of `Body` so that runtime code
+        can continue to use `isinstance(param.annotation, Body)`.
+        """
+        return cls(item)
+
+class Router:
+    """Minimal router to simplify Datasette plugin route registration and OpenAPI export."""
+
+    def __init__(self, title: str = "API", version: str = "0.0.0", server_url: str = "http://localhost:8001") -> None:
+        self._routes: List[Route] = []
+        self.title = title
+        self.version = version
+        self.server_url = server_url
+
+    def POST(self, path: str, *, output: Optional[type] = None):
+        return self._add_route("post", path, output=output)
+
+    def GET(self, path: str, *, output: Optional[type] = None):
+        return self._add_route("get", path, output=output)
+
+    def _add_route(self, method: str, path: str, *, output: Optional[type]):
+        def decorator(fn: Callable):
+            # create route entry and compute/store input/output schemas now so
+            # we don't need to keep references to the original function
+            entry = Route(path=path, output=output, method=method, fn=None)
+            input_model = None
+            # inspect the handler's annotations for Body[...] parameters or Annotated[..., Body()]
+            try:
+                for _, param in inspect.signature(fn).parameters.items():
+                    # Check for Annotated[Model, Body()] pattern
+                    if get_origin(param.annotation) is Annotated:
+                        args = get_args(param.annotation)
+                        if len(args) >= 2:
+                            # args[0] is the actual type, args[1:] are metadata
+                            for metadata in args[1:]:
+                                if isinstance(metadata, Body):
+                                    input_model = args[0]
+                                    break
+                        if input_model:
+                            break
+                    # Check for backwards-compatible Body[Model] pattern
+                    elif isinstance(param.annotation, Body):
+                        input_model = param.annotation.model
+                        break
+            except Exception:
+                input_model = None
+
+            if input_model is not None:
+                entry.input_schema = _model_to_schema(input_model) or {"type": "object"}
+
+            # determine output schema from explicit `output` if provided
+            if entry.output is not None:
+                entry.output_schema = _model_to_schema(entry.output) or {"type": "object"}
+
+            # append entry after computing schemas
+            self._routes.append(entry)
+
+            async def view(request, datasette=None, scope=None, receive=None, send=None):
+                declared_kwargs = inspect.signature(fn).parameters
+                kwargs = {}
+                for name, param in declared_kwargs.items():
+                    if name == "request":
+                        kwargs["request"] = request
+                        continue
+                    elif name == "datasette":
+                        kwargs["datasette"] = datasette
+                        continue
+                    elif name == "scope":
+                        kwargs["scope"] = scope
+                        continue
+                    elif name == "receive":
+                        kwargs["receive"] = receive
+                        continue
+                    elif name == "send":
+                        kwargs["send"] = send
+                        continue
+                    
+                    # Check for Annotated[Model, Body()] pattern
+                    body_model = None
+                    if get_origin(param.annotation) is Annotated:
+                        args = get_args(param.annotation)
+                        if len(args) >= 2:
+                            for metadata in args[1:]:
+                                if isinstance(metadata, Body):
+                                    body_model = args[0]
+                                    break
+                    # Check for backwards-compatible Body[Model] pattern
+                    elif isinstance(param.annotation, Body):
+                        body_model = param.annotation.model
+                    
+                    if body_model is not None:
+                        data = await request.post_body()
+                        model_instance = body_model.model_validate_json(data)  # type: ignore[attr-defined]
+                        kwargs[name] = model_instance
+                        continue
+                    
+                    # see if the str parameter exists in `request.url_vars`.
+                    if param.annotation is str:
+                        kwargs[name] = request.url_vars[name]
+                        continue
+
+                return await fn(**kwargs)
+
+            # replace the stored fn with the wrapper that Datasette should call
+            entry.fn = view
+            return view
+
+        return decorator
+
+    def routes(self) -> List[Tuple[str, Callable]]:
+        """Return a list of (regex, view_fn) tuples suitable for Datasette's register_routes."""
+        out: List[Tuple[str, Callable]] = []
+        for entry in self._routes:
+            if entry.fn is not None:
+                out.append((entry.path, entry.fn))
+        return out
+
+    def openapi_document_json(self) -> Dict[str, Any]:
+        """Return a minimal OpenAPI 3 document as a Python dict."""
+        components_schemas: Dict[str, Any] = {}
+
+        doc: Dict[str, Any] = {
+            "openapi": "3.0.0",
+            "info": {"title": self.title, "version": self.version},
+            "servers": [{"url": self.server_url}],
+            "paths": {},
+        }
+
+        for entry in self._routes:
+            path = entry.path
+            openapi_path = _regex_to_openapi_path(path)
+            method = entry.method.lower()
+
+            parameters: List[Dict[str, Any]] = []
+            for name in _extract_named_groups(path):
+                parameters.append({"name": name, "in": "path", "required": True, "schema": {"type": "string"}})
+
+            operation: Dict[str, Any] = {"responses": {"200": {"description": "OK"}}, "parameters": parameters}
+
+            # Use precomputed schemas stored on the Route entry
+            if entry.input_schema is not None:
+                # Extract $defs and rewrite $refs for OpenAPI 3.0 compatibility
+                processed_schema = _extract_defs_from_schema(entry.input_schema, components_schemas)
+                operation["requestBody"] = {"required": True, "content": {"application/json": {"schema": processed_schema}}}
+
+            if entry.output is not None:
+                schema = _model_to_schema(entry.output) or {"type": "object"}
+                # Extract $defs and rewrite $refs for OpenAPI 3.0 compatibility
+                processed_schema = _extract_defs_from_schema(schema, components_schemas)
+                operation["responses"]["200"]["content"] = {"application/json": {"schema": processed_schema}}
+
+            doc["paths"].setdefault(openapi_path, {})[method] = operation
+
+        # Add components.schemas if any $defs were extracted
+        if components_schemas:
+            doc["components"] = {"schemas": components_schemas}
+
+        return doc
+
+def _model_to_schema(model: type) -> Optional[Dict[str, Any]]:
+    if model is None:
+        return None
+    mjs = getattr(model, "model_json_schema", None)
+    if callable(mjs):
+        try:
+            return mjs()  # type: ignore[no-any-return]
+        except Exception:
+            pass
+    schema_fn = getattr(model, "schema", None)
+    if callable(schema_fn):
+        try:
+            return schema_fn()  # type: ignore[no-any-return]
+        except Exception:
+            pass
+    ann = getattr(model, "__annotations__", None)
+    if isinstance(ann, dict):
+        return {"type": "object", "properties": {k: {"type": "string"} for k in ann.keys()}}
+    return None
+
+
+def _extract_defs_from_schema(schema: Dict[str, Any], components_schemas: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract $defs from a schema, add them to components_schemas, and rewrite $refs.
+
+    Pydantic's model_json_schema() generates JSON Schema 2020-12 style with $defs
+    for nested model references. OpenAPI 3.0 expects schemas under #/components/schemas/.
+    This function extracts $defs, moves them to components_schemas, and rewrites
+    $ref values from #/$defs/ModelName to #/components/schemas/ModelName.
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    # Make a copy to avoid mutating the original
+    schema = dict(schema)
+
+    # Extract $defs and add to components_schemas
+    if "$defs" in schema:
+        defs = schema.pop("$defs")
+        for name, definition in defs.items():
+            # Recursively process nested $defs in definitions
+            processed_def = _rewrite_refs(definition)
+            components_schemas[name] = processed_def
+
+    # Rewrite $refs in the schema
+    return _rewrite_refs(schema)
+
+
+def _rewrite_refs(obj: Any) -> Any:
+    """Recursively rewrite $ref values from #/$defs/X to #/components/schemas/X."""
+    if isinstance(obj, dict):
+        result = {}
+        for key, value in obj.items():
+            if key == "$ref" and isinstance(value, str) and value.startswith("#/$defs/"):
+                # Rewrite the ref to point to components/schemas
+                model_name = value[len("#/$defs/"):]
+                result[key] = f"#/components/schemas/{model_name}"
+            else:
+                result[key] = _rewrite_refs(value)
+        return result
+    elif isinstance(obj, list):
+        return [_rewrite_refs(item) for item in obj]
+    else:
+        return obj
+
+
+def _extract_named_groups(regex: str) -> List[str]:
+    pattern = re.compile(regex)
+    return list(pattern.groupindex.keys())
+
+def _regex_to_openapi_path(regex: str) -> str:
+    try:
+        path = regex
+        if path.startswith("^"):
+            path = path[1:]
+        if path.endswith("$"):
+            path = path[:-1]
+        path = re.sub(r"\(\?P<([^>]+)>[^)]+\)", r"{\1}", path)
+        return path
+    except Exception:
+        return regex

datasette_plugin_router-0.0.1a2.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: datasette-plugin-router
+Version: 0.0.1a2
+Summary: WIP router for Datasette plugins
+Author: Alex Garcia
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/datasette/datasette-plugin-router
+Project-URL: Changelog, https://github.com/datasette/datasette-plugin-router/releases
+Project-URL: Issues, https://github.com/datasette/datasette-plugin-router/issues
+Project-URL: CI, https://github.com/datasette/datasette-plugin-router/actions
+Classifier: Framework :: Datasette
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: datasette>=1a23
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-openapi>=0.2.0
+Dynamic: license-file
+
+# datasette-plugin-router
+
+[![PyPI](https://img.shields.io/pypi/v/datasette-plugin-router.svg)](https://pypi.org/project/datasette-plugin-router/)
+[![Changelog](https://img.shields.io/github/v/release/datasette/datasette-plugin-router?include_prereleases&label=changelog)](https://github.com/datasette/datasette-plugin-router/releases)
+[![Tests](https://github.com/datasette/datasette-plugin-router/actions/workflows/test.yml/badge.svg)](https://github.com/datasette/datasette-plugin-router/actions/workflows/test.yml)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/datasette/datasette-plugin-router/blob/main/LICENSE)
+
+WIP router for Datasette plugins
+
+Datasette plugins that have a lot of [custom API endpoints](https://docs.datasette.io/en/stable/plugin_hooks.html#register-routes-datasette) can get tiresome to write by hand.  `datasette-plugin-router` aims to be a small Python library that adds a FastAPI-like API for defining custom Datasette plugin endpoints.
+
+- Define routes with familiar GET/POST decorators
+- Define Pydantic-backed input/output schemas on JSON endpoints
+- `register_routes()` compatability
+- export to OpenAPI schema for codegen'ing clients
+
+
+Sample usage:
+
+```python
+from datasette import Response, hookimpl
+from datasette_plugin_router import Router, Body
+from pydantic import BaseModel
+
+router = Router()
+
+class Input(BaseModel):
+    id: int
+    name: str
+
+class Output(BaseModel):
+    id_negative: int
+    name_upper: str
+
+@router.POST(r"/-/demo1$", output=Output)
+async def demo1(params: Body[Input]) -> Output:
+    output = Output(
+        id_negative=-1 * params.id,
+        name_upper=params.name.upper(),
+    )
+    return Response.json(output.model_dump())
+
+
+@router.GET(r"/-/hello/(?P<name>.*)$")
+async def hello(name: str):
+    return Response.html(f"<h1>Hello, {name}!</h1>")
+
+
+@hookimpl
+def register_routes():
+    return router.routes()
+
+```

datasette_plugin_router-0.0.1a2.dist-info/RECORD

@@ -0,0 +1,8 @@
+datasette_plugin_router/__init__.py,sha256=Hob8dbfwKJ8gOejDutdlC3wNPTlQJ4ECkQz_Q8b51PM,11687
+datasette_plugin_router-0.0.1a2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tests/test_plugin_router.py,sha256=OoMEFsjPEmLK1aI5VL0MMBM-OGFPdI7QXuXeBp8h-UE,5747
+datasette_plugin_router-0.0.1a2.dist-info/METADATA,sha256=Fpp_qVcz_d-LWaWm1R51Izz1I8HHGpfFU2oeHrxv9RQ,2656
+datasette_plugin_router-0.0.1a2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+datasette_plugin_router-0.0.1a2.dist-info/entry_points.txt,sha256=t3H60Uv6J7kUBQpJLGrtKtX0IG4a-qP92GHZ2OhYyxM,52
+datasette_plugin_router-0.0.1a2.dist-info/top_level.txt,sha256=1yxh_A8rPbDc9d97jjp0B9QNTPxRyqpbC_v03vAm-vc,30
+datasette_plugin_router-0.0.1a2.dist-info/RECORD,,

datasette_plugin_router-0.0.1a2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

datasette_plugin_router-0.0.1a2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[datasette]
+plugin_router = datasette_plugin_router

datasette_plugin_router-0.0.1a2.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

datasette_plugin_router-0.0.1a2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+datasette_plugin_router
+tests

tests/test_plugin_router.py

@@ -0,0 +1,157 @@
+from datasette.app import Datasette
+import pytest
+from datasette_plugin_router import Router, Body
+from pydantic import BaseModel
+from datasette import hookimpl, Response
+from typing import List, Annotated
+
+@pytest.mark.asyncio
+async def test_plugin_is_installed():
+    datasette = Datasette(memory=True)
+    response = await datasette.client.get("/-/plugins.json")
+    assert response.status_code == 200
+    installed_plugins = {p["name"] for p in response.json()}
+    assert "datasette-plugin-router" in installed_plugins
+
+
+
+@pytest.mark.asyncio
+async def test_spec(snapshot):
+    datasette = Datasette(memory=True)
+    class Input(BaseModel):
+        id: int
+
+    class Output(BaseModel):
+        id_negative: int
+
+    router = Router(title="Test API", version="1.2.3", server_url="http://example.com")
+
+    @router.POST("/test", output=Output)
+    async def test_endpoint(params: Annotated[Input, Body()]):
+        return Response.json(Output(id_negative=-1 * params.id).model_dump())
+    
+    @router.GET(r"/hello/(?P<name>.*)$")
+    async def hello(name: str):
+        return Response.html(f"<h1>Hello, {name}!</h1>")
+    
+    assert router.openapi_document_json() == snapshot(name="router spec")
+    
+    class TestPlugin:
+        __name__ = "TestPlugin"
+
+        @hookimpl
+        def register_routes(datasette):
+            return router.routes()
+    
+    try:
+        datasette.pm.register(TestPlugin(), name="test-plugin")
+
+        result = await datasette.client.post("/test", json={"id": 42})
+        assert result.status_code == 200
+        assert result.json() == {"id_negative": -42}
+
+    finally:
+        datasette.pm.unregister(name="test-plugin")
+
+
+@pytest.mark.asyncio
+async def test_nested_pydantic_models_openapi():
+    """Test that nested Pydantic models generate valid OpenAPI with components.schemas."""
+    
+    class DocumentListItem(BaseModel):
+        id: int
+        title: str
+    
+    class DocumentListOutput(BaseModel):
+        documents: List[DocumentListItem]
+        total: int
+
+    router = Router(title="Nested API", version="1.0.0", server_url="http://example.com")
+
+    @router.GET("/documents", output=DocumentListOutput)
+    async def list_documents():
+        return Response.json({"documents": [], "total": 0})
+    
+    spec = router.openapi_document_json()
+    
+    # Verify that $defs was extracted and moved to components.schemas
+    assert "components" in spec, "Should have components section"
+    assert "schemas" in spec["components"], "Should have schemas in components"
+    assert "DocumentListItem" in spec["components"]["schemas"], "Should have DocumentListItem in schemas"
+    
+    # Verify the nested model schema is correct
+    item_schema = spec["components"]["schemas"]["DocumentListItem"]
+    assert item_schema["type"] == "object"
+    assert "id" in item_schema["properties"]
+    assert "title" in item_schema["properties"]
+    
+    # Verify the response schema uses the correct $ref
+    response_schema = spec["paths"]["/documents"]["get"]["responses"]["200"]["content"]["application/json"]["schema"]
+    assert "$defs" not in response_schema, "Should not have $defs in inline schema"
+    
+    # Verify the $ref points to components/schemas
+    docs_property = response_schema["properties"]["documents"]
+    assert docs_property["items"]["$ref"] == "#/components/schemas/DocumentListItem"
+
+
+@pytest.mark.asyncio
+async def test_annotated_body_syntax():
+    """Test that Annotated[Model, Body()] syntax works for type-safe parameters."""
+    datasette = Datasette(memory=True)
+    
+    class Input(BaseModel):
+        id: int
+        name: str
+
+    class Output(BaseModel):
+        id_negative: int
+        name_upper: str
+
+    router = Router(title="Annotated API", version="1.0.0", server_url="http://example.com")
+
+    # Using Annotated[Model, Body()] for full type safety
+    @router.POST("/annotated-test", output=Output)
+    async def test_endpoint(params: Annotated[Input, Body()]):
+        # params is now properly typed as Input, not Body[Input]
+        # Type checkers understand params.id is int, params.name is str
+        return Response.json(Output(
+            id_negative=-1 * params.id,
+            name_upper=params.name.upper()
+        ).model_dump())
+    
+    class TestPlugin:
+        __name__ = "AnnotatedTestPlugin"
+
+        @hookimpl
+        def register_routes(datasette):
+            return router.routes()
+    
+    try:
+        datasette.pm.register(TestPlugin(), name="annotated-test-plugin")
+
+        # Test the endpoint works correctly
+        result = await datasette.client.post("/annotated-test", json={"id": 42, "name": "hello"})
+        assert result.status_code == 200
+        assert result.json() == {"id_negative": -42, "name_upper": "HELLO"}
+        
+        # Verify OpenAPI spec is generated correctly
+        spec = router.openapi_document_json()
+        assert "/annotated-test" in spec["paths"]
+        post_spec = spec["paths"]["/annotated-test"]["post"]
+        
+        # Should have request body schema
+        assert "requestBody" in post_spec
+        assert post_spec["requestBody"]["required"] is True
+        request_schema = post_spec["requestBody"]["content"]["application/json"]["schema"]
+        assert "properties" in request_schema
+        assert "id" in request_schema["properties"]
+        assert "name" in request_schema["properties"]
+        
+        # Should have response schema
+        response_schema = post_spec["responses"]["200"]["content"]["application/json"]["schema"]
+        assert "properties" in response_schema
+        assert "id_negative" in response_schema["properties"]
+        assert "name_upper" in response_schema["properties"]
+
+    finally:
+        datasette.pm.unregister(name="annotated-test-plugin")