mountaineer 0.4.1.dev2__tar.gz → 0.4.1.dev3__tar.gz

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/Cargo.lock

@@ -535,7 +535,7 @@ dependencies = [
 
 [[package]]
 name = "mountaineer"
-version = "0.4.1-dev2"
+version = "0.4.1-dev3"
 dependencies = [
  "criterion",
  "deno_core_icudata",

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/Cargo.toml

@@ -15,7 +15,7 @@ harness = false
 
 [package]
 name = "mountaineer"
-version = "0.4.1-dev2"
+version = "0.4.1-dev3"
 edition = "2021"
 
 [dependencies]

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mountaineer
-Version: 0.4.1.dev2
+Version: 0.4.1.dev3
 Requires-Dist: pydantic
 Requires-Dist: fastapi
 Requires-Dist: inflection

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/mountaineer/__tests__/client_builder/test_build_actions.py

@@ -1,4 +1,6 @@
+from datetime import datetime
 from re import sub as re_sub
+from uuid import UUID
 
 import pytest
 from fastapi import APIRouter
@@ -125,6 +127,37 @@ EXAMPLE_RESPONSE_400 = ContentBodyDefinition(
                 "ExampleResponseModel",
             ],
         ),
+        # No request body parameter
+        (
+            "my_method_fn",
+            "/testing/url",
+            ActionDefinition(
+                action_type=ActionType.POST,
+                summary="",
+                operationId="",
+                requestBody=None,
+                responses={
+                    "200": EXAMPLE_RESPONSE_200,
+                    "422": EXAMPLE_RESPONSE_400,
+                },
+            ),
+            (
+                """
+                export const my_method_fn = (): Promise<ExampleResponseModel> => {
+                    return __request({
+                        'method': 'POST',
+                        'url': '/testing/url',
+                        'errors': {
+                            422: HTTPValidationErrorException
+                        }
+                    });
+                }
+                """
+            ),
+            [
+                "ExampleResponseModel",
+            ],
+        ),
         # Path and query parameters
         (
             "my_method_fn",
@@ -363,3 +396,30 @@ def test_build_raw_response_action(
     built_function, build_imports = builder.build_action(url, definition, method_name)
     assert re_sub(r"\s+", "", built_function) == re_sub(r"\s+", "", expected_function)
     assert set(build_imports) == set(expected_imports)
+
+
+AnyType = None | bool | str | int | datetime | UUID
+DictParamItem = dict[str, AnyType]
+
+
+def test_build_invalid_action_api():
+    """
+    Ensure that we throw an error if the user has provided a schema payload
+    that is technically valid, but doesn't allow typehinting with pydantic. All non-raw
+    JSON requests should be Pydantic methods.
+
+    https://github.com/piercefreeman/mountaineer/issues/94
+
+    """
+
+    def fn1(payload: DictParamItem, item_id: str, other_id: str) -> None:
+        pass
+
+    router = APIRouter()
+    router.post("/fn1")(fn1)
+
+    builder = OpenAPIToTypescriptActionConverter()
+    openapi_spec = get_openapi(title="", version="", routes=router.routes)
+
+    with pytest.raises(ValueError):
+        builder.convert(openapi_spec)

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/mountaineer/__tests__/client_builder/test_build_links.py

@@ -1,5 +1,7 @@
+from enum import StrEnum
 from re import sub as re_sub
 from typing import Callable
+from uuid import UUID
 
 import pytest
 from fastapi import APIRouter
@@ -20,6 +22,20 @@ def view_endpoint_query_params(query_a: str, query_b: int | None = None):
     pass
 
 
+class RouteType(StrEnum):
+    ROUTE_A = "route_a"
+    ROUTE_B = "route_b"
+
+
+def enum_view_url(model_type: RouteType, model_id: UUID):
+    """
+    Model view paths like /{model_type}/{model_id} where we want a flexible
+    string to be captured in the model_type path.
+
+    """
+    pass
+
+
 @pytest.mark.parametrize(
     "url, endpoint, expected_link",
     [
@@ -98,6 +114,35 @@ def view_endpoint_query_params(query_a: str, query_b: int | None = None):
                 """
             ),
         ),
+        # Path with enum path variables - we should typehint explicitly
+        # as the enum based values
+        (
+            "/enum_view/{model_type}/{model_id}",
+            enum_view_url,
+            (
+                """
+                export const getLink = ({
+                    model_type,
+                    model_id
+                }:{
+                    model_type: 'route_a' | 'route_b',
+                    model_id: string
+                }) => {
+                    const url = `/enum_view/{model_type}/{model_id}`;
+                    const queryParameters: Record<string,any> = {};
+                    const pathParameters: Record<string,any> = {
+                        model_type,
+                        model_id
+                    };
+                    return __getLink({
+                        rawUrl: url,
+                        queryParameters,
+                        pathParameters
+                    });
+                };
+                """
+            ),
+        ),
     ],
 )
 def test_convert(url: str, endpoint: Callable, expected_link: str):

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/mountaineer/client_builder/build_actions.py

@@ -204,12 +204,16 @@ class OpenAPIToTypescriptActionConverter:
                 if not action.is_raw_response:
                     response_types.append(
                         self.get_typescript_name_from_content_definition(
-                            response_definition.content_schema
+                            response_definition.content_schema,
+                            url=url,
+                            status_code=status_int,
                         )
                     )
             else:
                 error_typehint = self.get_typescript_name_from_content_definition(
-                    response_definition.content_schema
+                    response_definition.content_schema,
+                    url=url,
+                    status_code=status_int,
                 )
                 common_params["errors"][status_int] = TSLiteral(
                     # Provide a mapping to the error class
@@ -253,11 +257,18 @@ class OpenAPIToTypescriptActionConverter:
         return method_names
 
     def get_typescript_name_from_content_definition(
-        self, definition: ContentDefinition
+        self,
+        definition: ContentDefinition,
+        # Url and status are provided for more context about where the error
+        # is being thrown. Can pass None if not available.
+        url: str | None = None,
+        status_code: int | None = None,
     ):
         if not definition.schema_ref.ref:
             raise ValueError(
-                f"Content definition {definition} does not have a schema reference"
+                f"Content definition {definition} does not have a schema reference.\n"
+                f"Double check your action definition for {url} with response code {status_code}.\n"
+                "Are you typehinting your response with a Pydantic BaseModel?"
             )
         return definition.schema_ref.ref.split("/")[-1]
 

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/mountaineer/client_builder/build_links.py

@@ -58,7 +58,9 @@ class OpenAPIToTypescriptLinkConverter:
             }:
                 continue
 
-            typehint_key, typehint_value = get_typehint_for_parameter(parameter)
+            typehint_key, typehint_value = get_typehint_for_parameter(
+                parameter, openapi_spec
+            )
             input_parameters[TSLiteral(parameter.name)] = TSLiteral(parameter.name)
             typehint_parameters[typehint_key] = typehint_value
 

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/mountaineer/client_builder/build_schemas.py

@@ -6,12 +6,13 @@ from typing import Any, Dict, Iterator, Type, get_args, get_origin
 from inflection import camelize
 from pydantic import BaseModel, create_model
 
-from mountaineer.annotation_helpers import get_value_by_alias, yield_all_subtypes
+from mountaineer.annotation_helpers import yield_all_subtypes
 from mountaineer.client_builder.openapi import (
     EmptyAPIProperty,
     OpenAPIProperty,
     OpenAPISchema,
     OpenAPISchemaType,
+    resolve_ref,
 )
 from mountaineer.client_builder.typescript import (
     TSLiteral,
@@ -103,7 +104,7 @@ class OpenAPIToTypescriptSchemaConverter:
             ):
                 yield property
             if property.ref is not None:
-                yield from walk_models(self.resolve_ref(property.ref, base))
+                yield from walk_models(resolve_ref(property.ref, base))
             if property.items:
                 yield from walk_models(property.items)
             if property.anyOf:
@@ -116,28 +117,6 @@ class OpenAPIToTypescriptSchemaConverter:
 
         return list(set(walk_models(base)))
 
-    def resolve_ref(self, ref: str, base: BaseModel) -> OpenAPIProperty:
-        """
-        Resolve a $ref that points to a propery-compliant schema in the same document. If this
-        ref points somewhere else in the document (that is valid but not a data model) than we
-        raise a ValueError.
-
-        """
-        current_obj = base
-        for part in ref.split("/"):
-            if part == "#":
-                current_obj = base
-            else:
-                try:
-                    current_obj = get_value_by_alias(current_obj, part)
-                except AttributeError as e:
-                    raise AttributeError(
-                        f"Invalid $ref, couldn't resolve path: {ref}"
-                    ) from e
-        if not isinstance(current_obj, OpenAPIProperty):
-            raise ValueError(f"Resolved $ref is not a valid OpenAPIProperty: {ref}")
-        return current_obj
-
     def convert_schema_to_interface(
         self,
         model: OpenAPIProperty,
@@ -188,7 +167,7 @@ class OpenAPIToTypescriptSchemaConverter:
                 yield f"Array<{' | '.join(array_types)}>"
             elif prop.ref:
                 yield self.get_typescript_interface_name(
-                    self.resolve_ref(prop.ref, base=base)
+                    resolve_ref(prop.ref, base=base)
                 )
             elif prop.items:
                 yield from walk_array_types(prop.items)

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/mountaineer/client_builder/openapi.py

@@ -4,6 +4,8 @@ from typing import Any, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
+from mountaineer.annotation_helpers import get_value_by_alias
+
 #
 # Enum definitions
 #
@@ -324,33 +326,24 @@ class OpenAPIDefinition(BaseModel):
 #
 
 
-def get_types_from_parameters(schema: OpenAPIProperty | EmptyAPIProperty):
+def resolve_ref(ref: str, base: BaseModel) -> OpenAPIProperty:
     """
-    Handle potentially complex types from the parameter schema, like the case
-    of optional fields.
+    Resolve a $ref that points to a propery-compliant schema in the same document. If this
+    ref points somewhere else in the document (that is valid but not a data model) than we
+    raise a ValueError.
 
     """
-    if isinstance(schema, EmptyAPIProperty):
-        return "any"
-
-    # Recursively gather all of the types that might be nested
-    if schema.variable_type:
-        yield schema.variable_type
-
-    for property in schema.properties.values():
-        yield from get_types_from_parameters(property)
-
-    if schema.additionalProperties:
-        yield from get_types_from_parameters(schema.additionalProperties)
-
-    if schema.items:
-        yield from get_types_from_parameters(schema.items)
-
-    if schema.anyOf:
-        for one_of in schema.anyOf:
-            yield from get_types_from_parameters(one_of)
-
-    # We don't expect $ref values in the URL schema, if we do then the parsing
-    # is likely incorrect
-    if schema.ref:
-        raise ValueError(f"Unexpected $ref in URL schema: {schema.ref}")
+    current_obj = base
+    for part in ref.split("/"):
+        if part == "#":
+            current_obj = base
+        else:
+            try:
+                current_obj = get_value_by_alias(current_obj, part)
+            except AttributeError as e:
+                raise AttributeError(
+                    f"Invalid $ref, couldn't resolve path: {ref}"
+                ) from e
+    if not isinstance(current_obj, OpenAPIProperty):
+        raise ValueError(f"Resolved $ref is not a valid OpenAPIProperty: {ref}")
+    return current_obj

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/mountaineer/client_builder/typescript.py

@@ -5,10 +5,14 @@ Python definitions.
 """
 from typing import Any
 
+from pydantic import BaseModel
+
 from mountaineer.client_builder.openapi import (
+    EmptyAPIProperty,
+    OpenAPIProperty,
     OpenAPISchemaType,
     URLParameterDefinition,
-    get_types_from_parameters,
+    resolve_ref,
 )
 
 
@@ -85,12 +89,62 @@ def map_openapi_type_to_ts(openapi_type: OpenAPISchemaType):
     return mapping[openapi_type]
 
 
-def get_typehint_for_parameter(parameter: URLParameterDefinition):
+def get_types_from_parameters(
+    schema: OpenAPIProperty | EmptyAPIProperty, base_openapi_spec: BaseModel | None
+):
+    """
+    Handle potentially complex types from the parameter schema, like the case
+    of optional fields.
+
+    """
+    if isinstance(schema, EmptyAPIProperty):
+        return "any"
+
+    # Recursively gather all of the types that might be nested
+    for property in schema.properties.values():
+        yield from get_types_from_parameters(property, base_openapi_spec)
+
+    if schema.additionalProperties:
+        yield from get_types_from_parameters(
+            schema.additionalProperties, base_openapi_spec
+        )
+
+    if schema.items:
+        yield from get_types_from_parameters(schema.items, base_openapi_spec)
+
+    if schema.anyOf:
+        for one_of in schema.anyOf:
+            yield from get_types_from_parameters(one_of, base_openapi_spec)
+
+    # Mutually exclusive definitions
+    if schema.enum:
+        yield " | ".join([f"'{enum_value}'" for enum_value in schema.enum])
+    elif schema.variable_type:
+        yield map_openapi_type_to_ts(schema.variable_type)
+
+    # If we're able to resolve the ref, do so. Some clients call this to get a limited
+    # scope of known parameters, so this value is optional.
+    if schema.ref:
+        if base_openapi_spec:
+            ref = resolve_ref(schema.ref, base_openapi_spec)
+            yield from get_types_from_parameters(ref, base_openapi_spec)
+        else:
+            raise ValueError(
+                f"Unexpected $ref in schema: {schema.ref}, no base schema passed for resolution"
+            )
+
+
+def get_typehint_for_parameter(
+    parameter: URLParameterDefinition, base: BaseModel | None = None
+):
     """
     Get the typehint for a parameter, which may be a single type or a union of types.
 
+    Providing the "base" OpenAPI schema allows us to resolve refs. Otherwise we will just
+    parse the types directly from the parameter and throw an error on ref resolution.
+
     """
-    parameter_types = set(get_types_from_parameters(parameter.schema_ref))
+    parameter_types = set(get_types_from_parameters(parameter.schema_ref, base))
 
     key = TSLiteral(parameter.name) + (
         TSLiteral("?") if not parameter.required else TSLiteral("")
@@ -98,7 +152,7 @@ def get_typehint_for_parameter(parameter: URLParameterDefinition):
     value = TSLiteral(
         " | ".join(
             # Sort helps with consistency of generated code
-            sorted([map_openapi_type_to_ts(raw_type) for raw_type in parameter_types])
+            sorted(parameter_types)
         )
     )
 

{mountaineer-0.4.1.dev2 → mountaineer-0.4.1.dev3}/pyproject.toml

@@ -9,7 +9,7 @@ exclude = [ "fixtures", "ci_webapp", "create_mountaineer_app", "media", "docs_we
 
 [tool.poetry]
 name = "mountaineer"
-version = "0.4.1.dev2"
+version = "0.4.1.dev3"
 description = ""
 authors = [ "Pierce Freeman <pierce@freeman.vc>",]
 readme = "README.md"