apcore-toolkit 0.2.0__tar.gz → 0.3.0__tar.gz

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.3.0] - 2026-03-19
+
+### Added
+
+- `_deep_resolve_refs()` — recursive `$ref` resolution for nested OpenAPI schemas,
+  handling `allOf`/`anyOf`/`oneOf`, `items`, and `properties`. Depth-limited to 16
+  levels to prevent infinite recursion on circular references.
+- `Enhancer` protocol — pluggable interface for metadata enhancement, allowing
+  custom enhancers beyond the built-in `AIEnhancer`.
+- `HTTPProxyRegistryWriter` — registers scanned modules as HTTP proxy classes
+  that forward requests to a running web API. Supports path parameter substitution,
+  pluggable auth headers, and `2xx` success range (with `204` returning `{}`).
+  Requires optional `httpx` dependency (`pip install apcore-toolkit[http-proxy]`).
+- `get_writer("http-proxy", base_url=...)` — factory support for the new
+  HTTP proxy writer with `**kwargs` forwarding.
+- Expanded `__init__.py` public API: exports `Enhancer`, `HTTPProxyRegistryWriter`,
+  `WriteError`, `Verifier`, `VerifyResult`, verifier classes, serializer functions,
+  `resolve_ref`, `resolve_schema`, `extract_input_schema`, `extract_output_schema`,
+  and `run_verifier_chain`.
+
+### Fixed
+
+- `extract_output_schema()` — now recursively resolves all nested `$ref` pointers
+  (previously only handled the shallow case of array items with `$ref`).
+- `extract_input_schema()` — now recursively resolves `$ref` inside individual
+  properties after assembly.
+- `get_writer()` return type annotation now includes `HTTPProxyRegistryWriter`.
+
+### Tests
+
+- 272 tests (up from 260), all passing
+- Added `TestDeepResolveRefs` (8 tests): top-level ref, nested properties,
+  allOf/anyOf, array items, deeply nested refs, circular ref depth limit,
+  immutability guarantee
+- Added nested `$ref` tests for `extract_input_schema` and `extract_output_schema`
+- Added `test_http_proxy` for `get_writer("http-proxy")` factory
+
+---
+
 ## [0.2.0] - 2026-03-11
 
 ### Added

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apcore-toolkit
-Version: 0.2.0
+Version: 0.3.0
 Summary: Shared scanner, schema extraction, and output toolkit for apcore framework adapters
 Project-URL: Homepage, https://aipartnerup.com
 Project-URL: Repository, https://github.com/aipartnerup/apcore-toolkit-python
@@ -10,15 +10,18 @@ Author-email: aipartnerup <tercel.yi@gmail.com>
 License-Expression: Apache-2.0
 Keywords: apcore,mcp,openapi,pydantic,scanner,schema,toolkit,yaml
 Requires-Python: >=3.11
-Requires-Dist: apcore>=0.13.0
+Requires-Dist: apcore>=0.13.1
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: apdev[dev]>=0.2.1; extra == 'dev'
+Requires-Dist: httpx>=0.24; extra == 'dev'
 Requires-Dist: mypy>=1.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff>=0.1; extra == 'dev'
+Provides-Extra: http-proxy
+Requires-Dist: httpx>=0.24; extra == 'http-proxy'
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -47,6 +50,8 @@ pip install apcore-toolkit
 | `YAMLWriter` | Generates `.binding.yaml` files for `apcore.BindingLoader` |
 | `PythonWriter` | Generates `@module`-decorated Python wrapper files |
 | `RegistryWriter` | Registers modules directly into an `apcore.Registry` |
+| `HTTPProxyRegistryWriter` | Registers HTTP proxy modules that forward requests to a running API |
+| `Enhancer` | Pluggable protocol for metadata enhancement |
 | `AIEnhancer` | SLM-based metadata enhancement for scanned modules |
 | `WriteResult` | Structured result type for all writer operations |
 | `WriteError` | Error class for I/O failures during write |

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/README.md

@@ -24,6 +24,8 @@ pip install apcore-toolkit
 | `YAMLWriter` | Generates `.binding.yaml` files for `apcore.BindingLoader` |
 | `PythonWriter` | Generates `@module`-decorated Python wrapper files |
 | `RegistryWriter` | Registers modules directly into an `apcore.Registry` |
+| `HTTPProxyRegistryWriter` | Registers HTTP proxy modules that forward requests to a running API |
+| `Enhancer` | Pluggable protocol for metadata enhancement |
 | `AIEnhancer` | SLM-based metadata enhancement for scanned modules |
 | `WriteResult` | Structured result type for all writer operations |
 | `WriteError` | Error class for I/O failures during write |

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apcore-toolkit"
-version = "0.2.0"
+version = "0.3.0"
 description = "Shared scanner, schema extraction, and output toolkit for apcore framework adapters"
 requires-python = ">=3.11"
 readme = "README.md"
@@ -23,18 +23,20 @@ keywords = [
     "toolkit",
 ]
 dependencies = [
-    "apcore>=0.13.0",
+    "apcore>=0.13.1",
     "pydantic>=2.0",
     "PyYAML>=6.0",
 ]
 
 [project.optional-dependencies]
+http-proxy = ["httpx>=0.24"]
 dev = [
     "pytest>=7.0",
     "pytest-cov>=4.0",
     "ruff>=0.1",
     "mypy>=1.0",
     "apdev[dev]>=0.2.1",
+    "httpx>=0.24",
 ]
 
 [project.urls]

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/src/apcore_toolkit/__init__.py

@@ -5,16 +5,33 @@ Public API re-exports for convenient access to core types and utilities.
 
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as _get_version
-from apcore_toolkit.ai_enhancer import AIEnhancer
+from apcore_toolkit.ai_enhancer import AIEnhancer, Enhancer
 from apcore_toolkit.formatting import to_markdown
+from apcore_toolkit.openapi import (
+    extract_input_schema,
+    extract_output_schema,
+    resolve_ref,
+    resolve_schema,
+)
 from apcore_toolkit.output import get_writer
+from apcore_toolkit.output.errors import WriteError
 from apcore_toolkit.output.python_writer import PythonWriter
+from apcore_toolkit.output.http_proxy_writer import HTTPProxyRegistryWriter
 from apcore_toolkit.output.registry_writer import RegistryWriter
-from apcore_toolkit.output.types import WriteResult
+from apcore_toolkit.output.types import Verifier, VerifyResult, WriteResult
+from apcore_toolkit.output.verifiers import (
+    JSONVerifier,
+    MagicBytesVerifier,
+    RegistryVerifier,
+    SyntaxVerifier,
+    YAMLVerifier,
+    run_verifier_chain,
+)
 from apcore_toolkit.output.yaml_writer import YAMLWriter
 from apcore_toolkit.pydantic_utils import flatten_pydantic_params, resolve_target
 from apcore_toolkit.scanner import BaseScanner
 from apcore_toolkit.schema_utils import enrich_schema_descriptions
+from apcore_toolkit.serializers import annotations_to_dict, module_to_dict, modules_to_dicts
 from apcore_toolkit.types import ScannedModule
 
 try:
@@ -25,14 +42,32 @@ except PackageNotFoundError:
 __all__ = [
     "AIEnhancer",
     "BaseScanner",
+    "HTTPProxyRegistryWriter",
+    "Enhancer",
+    "JSONVerifier",
+    "MagicBytesVerifier",
     "PythonWriter",
+    "RegistryVerifier",
     "RegistryWriter",
     "ScannedModule",
+    "SyntaxVerifier",
+    "Verifier",
+    "VerifyResult",
+    "WriteError",
     "WriteResult",
+    "YAMLVerifier",
     "YAMLWriter",
+    "annotations_to_dict",
     "enrich_schema_descriptions",
+    "extract_input_schema",
+    "extract_output_schema",
     "flatten_pydantic_params",
     "get_writer",
+    "module_to_dict",
+    "modules_to_dicts",
+    "resolve_ref",
+    "resolve_schema",
     "resolve_target",
+    "run_verifier_chain",
     "to_markdown",
 ]

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/src/apcore_toolkit/ai_enhancer.py

@@ -14,7 +14,7 @@ import json
 import logging
 import os
 from dataclasses import replace
-from typing import Any
+from typing import Any, Protocol
 
 from apcore import ModuleAnnotations
 
@@ -30,6 +30,16 @@ _DEFAULT_TIMEOUT = 30
 _DEFAULT_ANNOTATIONS = ModuleAnnotations()
 
 
+class Enhancer(Protocol):
+    """Protocol for pluggable metadata enhancement.
+
+    Any class implementing this protocol can be used to fill metadata gaps
+    in scanned modules. See the AI Enhancement Guide for details.
+    """
+
+    def enhance(self, modules: list[ScannedModule]) -> list[ScannedModule]: ...
+
+
 class AIEnhancer:
     """Enhances ScannedModule metadata using a local SLM.
 

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/src/apcore_toolkit/openapi.py

@@ -48,6 +48,43 @@ def resolve_schema(
     return schema
 
 
+def _deep_resolve_refs(
+    schema: dict[str, Any],
+    openapi_doc: dict[str, Any],
+    _depth: int = 0,
+) -> dict[str, Any]:
+    """Recursively resolve all ``$ref`` pointers in a schema.
+
+    Handles nested ``$ref``, ``allOf``, ``anyOf``, ``oneOf``, and ``items``.
+    Depth-limited to 16 levels to prevent infinite recursion.
+    """
+    if _depth > 16:
+        return schema
+
+    if "$ref" in schema:
+        resolved = resolve_ref(schema["$ref"], openapi_doc)
+        return _deep_resolve_refs(resolved, openapi_doc, _depth + 1)
+
+    result = dict(schema)
+
+    # Resolve inside allOf/anyOf/oneOf
+    for key in ("allOf", "anyOf", "oneOf"):
+        if key in result and isinstance(result[key], list):
+            result[key] = [_deep_resolve_refs(item, openapi_doc, _depth + 1) for item in result[key]]
+
+    # Resolve array items
+    if "items" in result and isinstance(result["items"], dict):
+        result["items"] = _deep_resolve_refs(result["items"], openapi_doc, _depth + 1)
+
+    # Resolve nested properties
+    if "properties" in result and isinstance(result["properties"], dict):
+        result["properties"] = {
+            k: _deep_resolve_refs(v, openapi_doc, _depth + 1) for k, v in result["properties"].items()
+        }
+
+    return result
+
+
 def extract_input_schema(
     operation: dict[str, Any],
     openapi_doc: dict[str, Any] | None = None,
@@ -90,6 +127,11 @@ def extract_input_schema(
         schema["properties"].update(body_schema.get("properties", {}))
         schema["required"].extend(body_schema.get("required", []))
 
+    # Recursively resolve $ref inside individual properties
+    if openapi_doc:
+        for prop_name, prop_schema in list(schema["properties"].items()):
+            schema["properties"][prop_name] = _deep_resolve_refs(prop_schema, openapi_doc)
+
     return schema
 
 
@@ -114,9 +156,9 @@ def extract_output_schema(
         if "schema" in json_content:
             schema: dict[str, Any] = json_content["schema"]
             schema = resolve_schema(schema, openapi_doc)
-            # Handle array with $ref items
-            if schema.get("type") == "array" and "$ref" in schema.get("items", {}):
-                schema["items"] = resolve_schema(schema["items"], openapi_doc)
+            # Recursively resolve all nested $ref pointers
+            if openapi_doc:
+                schema = _deep_resolve_refs(schema, openapi_doc)
             return schema
 
     return {"type": "object", "properties": {}}

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/src/apcore_toolkit/output/__init__.py

@@ -5,6 +5,11 @@ Provides a factory function to obtain a writer by format name.
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from apcore_toolkit.output.http_proxy_writer import HTTPProxyRegistryWriter
+
 from apcore_toolkit.output.errors import WriteError as WriteError
 from apcore_toolkit.output.python_writer import PythonWriter
 from apcore_toolkit.output.registry_writer import RegistryWriter
@@ -19,11 +24,16 @@ from apcore_toolkit.output.verifiers import YAMLVerifier as YAMLVerifier
 from apcore_toolkit.output.yaml_writer import YAMLWriter
 
 
-def get_writer(output_format: str) -> YAMLWriter | PythonWriter | RegistryWriter:
+def get_writer(
+    output_format: str, **kwargs: Any
+) -> YAMLWriter | PythonWriter | RegistryWriter | HTTPProxyRegistryWriter:
     """Return a writer instance for the given output format.
 
     Args:
-        output_format: Output format name (``"yaml"``, ``"python"``, or ``"registry"``).
+        output_format: Output format name (``"yaml"``, ``"python"``,
+            ``"registry"``, or ``"http-proxy"``).
+        **kwargs: Passed to the writer constructor. For ``"http-proxy"``:
+            ``base_url``, ``auth_header_factory``, ``timeout``.
 
     Returns:
         A writer instance.
@@ -37,4 +47,8 @@ def get_writer(output_format: str) -> YAMLWriter | PythonWriter | RegistryWriter
         return PythonWriter()
     if output_format == "registry":
         return RegistryWriter()
+    if output_format == "http-proxy":
+        from apcore_toolkit.output.http_proxy_writer import HTTPProxyRegistryWriter
+
+        return HTTPProxyRegistryWriter(**kwargs)
     raise ValueError(f"Unknown output format: {output_format!r}")

apcore_toolkit-0.3.0/src/apcore_toolkit/output/http_proxy_writer.py

@@ -0,0 +1,185 @@
+"""HTTP proxy registry writer.
+
+Registers scanned modules as HTTP proxy classes that forward requests
+to a running web API. This enables CLI execution without invoking
+route handlers directly (which depend on framework DI systems).
+
+Requires the ``httpx`` optional dependency::
+
+    pip install apcore-toolkit[http-proxy]
+
+Usage::
+
+    from apcore_toolkit.output.http_proxy_writer import HTTPProxyRegistryWriter
+
+    writer = HTTPProxyRegistryWriter(
+        base_url="http://localhost:8000",
+        auth_header_factory=lambda: {"Authorization": "Bearer xxx"},
+    )
+    results = writer.write(modules, registry)
+
+The writer reads ``http_method`` and ``url_path`` from each
+``ScannedModule.metadata`` dict (the framework-agnostic convention).
+Framework-specific ``ScannedModule`` subclasses with top-level
+``http_method`` / ``url_path`` attributes are also supported.
+"""
+
+import logging
+import re
+from collections.abc import Callable
+from typing import Any
+
+from apcore import ModuleAnnotations, Registry
+from apcore_toolkit.output.types import WriteResult
+from apcore_toolkit.types import ScannedModule
+
+logger = logging.getLogger("apcore_toolkit")
+
+
+def _get_http_fields(mod: Any) -> tuple[str, str]:
+    """Extract http_method and url_path from a ScannedModule.
+
+    Supports both:
+    - Toolkit ScannedModule (fields in ``metadata`` dict)
+    - Framework-specific ScannedModule (top-level attributes)
+    """
+    http_method = getattr(mod, "http_method", None) or mod.metadata.get("http_method", "GET")
+    url_path = getattr(mod, "url_path", None) or mod.metadata.get("url_path", "/")
+    return str(http_method), str(url_path)
+
+
+class HTTPProxyRegistryWriter:
+    """Register scanned modules as HTTP proxy classes in the registry.
+
+    Each module's ``execute()`` sends an HTTP request to the target API
+    instead of calling the route handler directly.
+
+    Args:
+        base_url: Base URL of the target API (e.g. ``http://localhost:8000``).
+        auth_header_factory: Optional callable returning HTTP headers for
+            authentication (e.g. ``{"Authorization": "Bearer xxx"}``).
+            Called once per request.
+        timeout: HTTP request timeout in seconds.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        auth_header_factory: Callable[[], dict[str, str]] | None = None,
+        timeout: float = 60.0,
+    ) -> None:
+        self._base_url = base_url
+        self._auth_header_factory = auth_header_factory
+        self._timeout = timeout
+
+    def write(
+        self,
+        modules: list[ScannedModule],
+        registry: Registry,
+    ) -> list[WriteResult]:
+        """Register each ScannedModule as an HTTP proxy module."""
+        results: list[WriteResult] = []
+        for mod in modules:
+            try:
+                module_instance = self._build_module_class(mod)()
+                registry.register(mod.module_id, module_instance)
+                results.append(WriteResult(module_id=mod.module_id, path=None, verified=True))
+            except Exception as exc:
+                logger.debug("Skipped %s: %s", mod.module_id, exc)
+                results.append(
+                    WriteResult(
+                        module_id=mod.module_id,
+                        path=None,
+                        verified=False,
+                        verification_error=str(exc),
+                    )
+                )
+        return results
+
+    def _build_module_class(self, mod: ScannedModule) -> type:
+        """Build a module class with HTTP proxy execute method."""
+        http_method, url_path = _get_http_fields(mod)
+        path_params = set(re.findall(r"\{(\w+)\}", url_path))
+        base_url = self._base_url
+        auth_factory = self._auth_header_factory
+        timeout = self._timeout
+
+        annotations = mod.annotations or ModuleAnnotations()
+
+        # Raw dict schemas are auto-wrapped by Registry._ensure_schema_adapter
+        # (apcore >= 0.13.1) during register(), so no manual wrapping needed.
+        raw_input = dict(mod.input_schema)
+        raw_output = dict(mod.output_schema)
+
+        class ProxyModule:
+            input_schema = raw_input
+            output_schema = raw_output
+            description = mod.description
+            documentation = mod.documentation
+
+            async def execute(self, inputs: dict[str, Any], ctx: Any = None) -> dict[str, Any]:
+                import httpx as _httpx
+
+                headers: dict[str, str] = {}
+                if auth_factory is not None:
+                    headers.update(auth_factory())
+
+                actual_path = url_path
+                query: dict[str, Any] = {}
+                body: dict[str, Any] = {}
+
+                for key, value in inputs.items():
+                    if key in path_params:
+                        actual_path = actual_path.replace(f"{{{key}}}", str(value))
+                    elif http_method == "GET":
+                        query[key] = value
+                    else:
+                        body[key] = value
+
+                kwargs: dict[str, Any] = {}
+                if query:
+                    kwargs["params"] = query
+                if body and http_method in ("POST", "PUT", "PATCH"):
+                    kwargs["json"] = body
+
+                transport = _httpx.AsyncHTTPTransport(retries=0)
+                async with _httpx.AsyncClient(transport=transport, base_url=base_url, timeout=timeout) as client:
+                    resp = await client.request(http_method, actual_path, headers=headers, **kwargs)
+
+                if 200 <= resp.status_code < 300:
+                    if resp.status_code == 204:
+                        return {}
+                    return resp.json()  # type: ignore[no-any-return]
+
+                error_msg = _extract_error_message(resp)
+                from apcore.errors import ModuleError
+
+                raise ModuleError(
+                    code=f"HTTP_{resp.status_code}",
+                    message=error_msg,
+                )
+
+        ProxyModule.__name__ = mod.module_id.replace(".", "_")
+        ProxyModule.__qualname__ = ProxyModule.__name__
+        ProxyModule.annotations = annotations  # type: ignore[assignment]
+        ProxyModule.tags = mod.tags  # type: ignore[attr-defined]
+
+        return ProxyModule
+
+
+def _extract_error_message(resp: Any) -> str:
+    """Extract a human-readable error message from an HTTP error response."""
+    content_type = resp.headers.get("content-type", "")
+    if content_type.startswith("application/json"):
+        try:
+            body = resp.json()
+            return (
+                body.get("error_message")
+                or body.get("detail")
+                or body.get("error")
+                or body.get("message")
+                or resp.text[:200]
+            )
+        except Exception:
+            pass
+    return resp.text[:200]

apcore_toolkit-0.3.0/tests/test_http_proxy_writer.py

@@ -0,0 +1,204 @@
+"""Tests for HTTPProxyRegistryWriter."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+from apcore import Registry
+
+from apcore_toolkit.output.http_proxy_writer import HTTPProxyRegistryWriter
+from apcore_toolkit.types import ScannedModule
+
+
+def _make_module(
+    module_id: str = "test.get_items.get",
+    http_method: str = "GET",
+    url_path: str = "/items",
+    input_schema: dict[str, Any] | None = None,
+    output_schema: dict[str, Any] | None = None,
+) -> ScannedModule:
+    return ScannedModule(
+        module_id=module_id,
+        description=f"Test {module_id}",
+        input_schema=input_schema or {"type": "object", "properties": {}},
+        output_schema=output_schema or {"type": "object", "properties": {}},
+        tags=["test"],
+        target="test:func",
+        metadata={"http_method": http_method, "url_path": url_path},
+    )
+
+
+class TestHTTPProxyRegistryWriter:
+    def test_write_registers_all_modules(self) -> None:
+        registry = Registry()
+        writer = HTTPProxyRegistryWriter(base_url="http://localhost:8000")
+
+        modules = [
+            _make_module("test.list.get", "GET", "/items"),
+            _make_module("test.create.post", "POST", "/items"),
+            _make_module("test.get_item.get", "GET", "/items/{item_id}"),
+        ]
+
+        results = writer.write(modules, registry)
+        assert len(results) == 3
+        assert all(r.verified for r in results)
+
+    def test_write_returns_failure_for_bad_module(self) -> None:
+        registry = Registry()
+        writer = HTTPProxyRegistryWriter(base_url="http://localhost:8000")
+
+        # Module with nullable field via anyOf
+        mod = _make_module(
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "id": {"anyOf": [{"type": "string"}, {"type": "null"}]},
+                    "name": {"type": "string"},
+                },
+            }
+        )
+
+        results = writer.write([mod], registry)
+        # Should succeed or gracefully fail (no crash)
+        assert len(results) == 1
+
+    def test_proxy_sends_get_with_query_params(self) -> None:
+        registry = Registry()
+        writer = HTTPProxyRegistryWriter(
+            base_url="http://localhost:8000",
+            auth_header_factory=lambda: {"Authorization": "Bearer test-token"},
+        )
+
+        mod = _make_module(
+            input_schema={
+                "type": "object",
+                "properties": {"page": {"type": "integer"}, "size": {"type": "integer"}},
+            }
+        )
+        writer.write([mod], registry)
+
+        # Get the registered module instance
+        module_instance = registry._modules["test.get_items.get"]
+
+        # Mock httpx
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"items": [], "total": 0}
+
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=None)
+
+        import httpx
+
+        original = httpx.AsyncClient
+        httpx.AsyncClient = MagicMock(return_value=mock_client)
+
+        try:
+            result = asyncio.run(module_instance.execute({"page": 1, "size": 10}))
+            assert result == {"items": [], "total": 0}
+
+            # Verify the request was made with query params
+            mock_client.request.assert_called_once()
+            call_args = mock_client.request.call_args
+            assert call_args[0] == ("GET", "/items")
+            assert call_args[1]["params"] == {"page": 1, "size": 10}
+            assert call_args[1]["headers"]["Authorization"] == "Bearer test-token"
+        finally:
+            httpx.AsyncClient = original
+
+    def test_proxy_sends_post_with_json_body(self) -> None:
+        registry = Registry()
+        writer = HTTPProxyRegistryWriter(base_url="http://localhost:8000")
+
+        mod = _make_module(
+            module_id="test.create.post",
+            http_method="POST",
+            url_path="/items",
+            input_schema={
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+                "required": ["name"],
+            },
+        )
+        writer.write([mod], registry)
+
+        module_instance = registry._modules["test.create.post"]
+
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"id": "1", "name": "Test"}
+
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=None)
+
+        import httpx
+
+        original = httpx.AsyncClient
+        httpx.AsyncClient = MagicMock(return_value=mock_client)
+
+        try:
+            result = asyncio.run(module_instance.execute({"name": "Test"}))
+            assert result["name"] == "Test"
+
+            call_args = mock_client.request.call_args
+            assert call_args[0] == ("POST", "/items")
+            assert call_args[1]["json"] == {"name": "Test"}
+        finally:
+            httpx.AsyncClient = original
+
+    def test_proxy_substitutes_path_params(self) -> None:
+        registry = Registry()
+        writer = HTTPProxyRegistryWriter(base_url="http://localhost:8000")
+
+        mod = _make_module(
+            module_id="test.get_item.get",
+            http_method="GET",
+            url_path="/items/{item_id}",
+            input_schema={
+                "type": "object",
+                "properties": {"item_id": {"type": "string"}},
+                "required": ["item_id"],
+            },
+        )
+        writer.write([mod], registry)
+
+        module_instance = registry._modules["test.get_item.get"]
+
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"id": "abc", "name": "Item"}
+
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=None)
+
+        import httpx
+
+        original = httpx.AsyncClient
+        httpx.AsyncClient = MagicMock(return_value=mock_client)
+
+        try:
+            result = asyncio.run(module_instance.execute({"item_id": "abc"}))
+            assert result["id"] == "abc"
+
+            call_args = mock_client.request.call_args
+            # Path param should be substituted, not sent as query
+            assert call_args[0] == ("GET", "/items/abc")
+            assert "params" not in call_args[1] or call_args[1]["params"] == {}
+        finally:
+            httpx.AsyncClient = original
+
+    def test_no_auth_headers_when_factory_is_none(self) -> None:
+        writer = HTTPProxyRegistryWriter(base_url="http://localhost:8000")
+        assert writer._auth_header_factory is None
+
+    def test_custom_timeout(self) -> None:
+        writer = HTTPProxyRegistryWriter(base_url="http://localhost:8000", timeout=120.0)
+        assert writer._timeout == 120.0

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/tests/test_openapi.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from apcore_toolkit.openapi import (
+    _deep_resolve_refs,
     extract_input_schema,
     extract_output_schema,
     resolve_ref,
@@ -24,6 +25,35 @@ OPENAPI_DOC = {
                 "type": "array",
                 "items": {"$ref": "#/components/schemas/User"},
             },
+            "Address": {
+                "type": "object",
+                "properties": {
+                    "street": {"type": "string"},
+                    "city": {"type": "string"},
+                },
+            },
+            "UserWithAddress": {
+                "type": "object",
+                "properties": {
+                    "id": {"type": "integer"},
+                    "address": {"$ref": "#/components/schemas/Address"},
+                },
+            },
+            "AdminUser": {
+                "allOf": [
+                    {"$ref": "#/components/schemas/User"},
+                    {
+                        "type": "object",
+                        "properties": {"role": {"type": "string"}},
+                    },
+                ],
+            },
+            "SelfRef": {
+                "type": "object",
+                "properties": {
+                    "child": {"$ref": "#/components/schemas/SelfRef"},
+                },
+            },
         }
     }
 }
@@ -70,6 +100,74 @@ class TestResolveSchema:
         assert result == schema
 
 
+class TestDeepResolveRefs:
+    def test_top_level_ref(self) -> None:
+        schema = {"$ref": "#/components/schemas/User"}
+        result = _deep_resolve_refs(schema, OPENAPI_DOC)
+        assert result["type"] == "object"
+        assert "id" in result["properties"]
+        assert "name" in result["properties"]
+
+    def test_nested_ref_in_properties(self) -> None:
+        schema = {
+            "type": "object",
+            "properties": {
+                "address": {"$ref": "#/components/schemas/Address"},
+            },
+        }
+        result = _deep_resolve_refs(schema, OPENAPI_DOC)
+        assert result["properties"]["address"]["type"] == "object"
+        assert "street" in result["properties"]["address"]["properties"]
+
+    def test_ref_in_allof(self) -> None:
+        schema = {
+            "allOf": [
+                {"$ref": "#/components/schemas/User"},
+                {"type": "object", "properties": {"extra": {"type": "boolean"}}},
+            ]
+        }
+        result = _deep_resolve_refs(schema, OPENAPI_DOC)
+        assert result["allOf"][0]["type"] == "object"
+        assert "id" in result["allOf"][0]["properties"]
+        assert result["allOf"][1]["properties"]["extra"]["type"] == "boolean"
+
+    def test_ref_in_anyof(self) -> None:
+        schema = {
+            "anyOf": [
+                {"$ref": "#/components/schemas/User"},
+                {"$ref": "#/components/schemas/Address"},
+            ]
+        }
+        result = _deep_resolve_refs(schema, OPENAPI_DOC)
+        assert result["anyOf"][0]["type"] == "object"
+        assert "name" in result["anyOf"][0]["properties"]
+        assert "street" in result["anyOf"][1]["properties"]
+
+    def test_ref_in_array_items(self) -> None:
+        schema = {"type": "array", "items": {"$ref": "#/components/schemas/User"}}
+        result = _deep_resolve_refs(schema, OPENAPI_DOC)
+        assert result["items"]["type"] == "object"
+        assert "id" in result["items"]["properties"]
+
+    def test_deeply_nested_ref(self) -> None:
+        result = _deep_resolve_refs({"$ref": "#/components/schemas/UserWithAddress"}, OPENAPI_DOC)
+        assert result["properties"]["address"]["type"] == "object"
+        assert "street" in result["properties"]["address"]["properties"]
+
+    def test_circular_ref_depth_limit(self) -> None:
+        result = _deep_resolve_refs({"$ref": "#/components/schemas/SelfRef"}, OPENAPI_DOC)
+        # Should not raise — depth limit stops recursion.
+        assert result["type"] == "object"
+        assert "child" in result["properties"]
+
+    def test_no_mutation_of_original(self) -> None:
+        original_address = OPENAPI_DOC["components"]["schemas"]["Address"]
+        original_props = dict(original_address.get("properties", {}))
+        schema = {"$ref": "#/components/schemas/UserWithAddress"}
+        _deep_resolve_refs(schema, OPENAPI_DOC)
+        assert OPENAPI_DOC["components"]["schemas"]["Address"]["properties"] == original_props
+
+
 class TestExtractInputSchema:
     def test_query_and_path_params(self) -> None:
         operation = {
@@ -118,6 +216,16 @@ class TestExtractInputSchema:
         result = extract_input_schema(operation, OPENAPI_DOC)
         assert result["properties"]["user"]["type"] == "object"
 
+    def test_nested_ref_in_body_properties(self) -> None:
+        operation = {
+            "requestBody": {
+                "content": {"application/json": {"schema": {"$ref": "#/components/schemas/UserWithAddress"}}}
+            }
+        }
+        result = extract_input_schema(operation, OPENAPI_DOC)
+        assert result["properties"]["address"]["type"] == "object"
+        assert "street" in result["properties"]["address"]["properties"]
+
     def test_empty_operation(self) -> None:
         result = extract_input_schema({})
         assert result["type"] == "object"
@@ -184,6 +292,28 @@ class TestExtractOutputSchema:
         result = extract_output_schema(operation)
         assert result == {"type": "object", "properties": {}}
 
+    def test_nested_ref_in_response_properties(self) -> None:
+        operation = {
+            "responses": {
+                "200": {"content": {"application/json": {"schema": {"$ref": "#/components/schemas/UserWithAddress"}}}}
+            }
+        }
+        result = extract_output_schema(operation, OPENAPI_DOC)
+        assert result["type"] == "object"
+        assert result["properties"]["address"]["type"] == "object"
+        assert "street" in result["properties"]["address"]["properties"]
+
+    def test_allof_composition_in_response(self) -> None:
+        operation = {
+            "responses": {
+                "200": {"content": {"application/json": {"schema": {"$ref": "#/components/schemas/AdminUser"}}}}
+            }
+        }
+        result = extract_output_schema(operation, OPENAPI_DOC)
+        assert result["allOf"][0]["type"] == "object"
+        assert "id" in result["allOf"][0]["properties"]
+        assert result["allOf"][1]["properties"]["role"]["type"] == "string"
+
     def test_empty_responses(self) -> None:
         result = extract_output_schema({})
         assert result == {"type": "object", "properties": {}}

{apcore_toolkit-0.2.0 → apcore_toolkit-0.3.0}/tests/test_output_factory.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import pytest
 
 from apcore_toolkit.output import get_writer
+from apcore_toolkit.output.http_proxy_writer import HTTPProxyRegistryWriter
 from apcore_toolkit.output.python_writer import PythonWriter
 from apcore_toolkit.output.registry_writer import RegistryWriter
 from apcore_toolkit.output.yaml_writer import YAMLWriter
@@ -23,6 +24,10 @@ class TestGetWriter:
         writer = get_writer("registry")
         assert isinstance(writer, RegistryWriter)
 
+    def test_http_proxy(self) -> None:
+        writer = get_writer("http-proxy", base_url="http://localhost:8000")
+        assert isinstance(writer, HTTPProxyRegistryWriter)
+
     def test_unknown_format(self) -> None:
         with pytest.raises(ValueError, match="Unknown output format"):
             get_writer("json")