geniespec 0.1.1.dev6__tar.gz → 0.1.1.dev8__tar.gz

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geniespec
-Version: 0.1.1.dev6
+Version: 0.1.1.dev8
 Summary: Generate API code from an api.yaml spec
 License-Expression: MIT
 Requires-Dist: jinja2>=3.1.6
@@ -22,11 +22,52 @@ geniespec watch --spec api.yaml --target <python-server | typescript-client> [--
 ```
 
 - `build` writes the target's package into the output directory. Only files in that package are touched: changed files are rewritten and files it no longer generates are removed.
-  - `python-server`: `./<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`). Code run from the output directory imports it directly, e.g. `from my_service_api.v1 import api`. Needs `kiba-core` (`core.api`, `core.util.typing_util`), `pydantic` and `starlette`.
-  - `typescript-client`: `./<service>-api/v<major>/` (`client`, `endpoints`, `resources`, `index`) with a `<Service>ApiV<major>Client` that extends `@kibalabs/core`'s `ServiceClient`. Construct it with the url the API version is mounted at, e.g. `new MyServiceApiV1Client(requester, 'https://api.example.com/v1')`. Methods take path parameters, then a params object for the request fields, and return the response field; stream transitions take a callback for each item. Transitions with `responseType: redirect` or a `query-parameters` field are left out, as browsers open redirects directly and query-parameters fields receive third-party callbacks. Needs `@kibalabs/core`.
+  - `python-server`: `./<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`). Code run from the output directory imports it directly, e.g. `from my_service_api.v1 import api`. Needs `kiba-core` (`core.api`, `core.util.typing_util`; 0.5.3.dev87 or later for `File` fields), `pydantic` and `starlette`.
+  - `typescript-client`: `./<service>-api/v<major>/` (`client`, `endpoints`, `resources`, `index`) with a `<Service>ApiV<major>Client` that extends `@kibalabs/core`'s `ServiceClient`. Construct it with the url the API version is mounted at, e.g. `new MyServiceApiV1Client(requester, 'https://api.example.com/v1')`. Methods take path parameters, then a params object for the request fields, and return the response field; stream transitions take a callback for each item; transitions with `File` fields send a multipart form. Transitions with `responseType: redirect` or a `query-parameters` field are left out, as browsers open redirects directly and query-parameters fields receive third-party callbacks. Needs `@kibalabs/core`.
 - `watch` builds, then rebuilds whenever the spec changes. If the spec is invalid it logs the error and keeps the previous output. Given a command after `--`, it runs it once the first build is done, keeps rebuilding while it runs, exits with its exit code and stops it when watch itself is stopped, e.g. `geniespec watch --spec api.yaml --target python-server -- uvicorn app:app --reload`.
 - The bundled templates are examples of a kibalabs-style target.
 
+## Enums, oneOfs and files
+
+Enums are string values limited to a list. Name them at the top level to reuse them, or give a field its own:
+
+```yaml
+enums:
+  - name: ViewKind
+    values: [member, cycle-start]
+resources:
+  - singleName: View
+    collectionName: Views
+    attributes:
+      - name: kind
+        type: ViewKind
+      - name: size
+        type: Enum
+        enumValues: [small, large]
+```
+
+`python-server` types them as `typing.Literal[...]` (named ones as `ViewKindV1` in `resources`) and rejects requests with other values; `typescript-client` types them as `'member' | 'cycle-start'` (named ones as an exported `ViewKindV1`).
+
+`type: File` request fields upload a file. They are only allowed on POST transitions, and the transition's other fields must be single primitive or enum values, as the request is sent as a multipart form. Internal methods receive kiba-core's `UploadedFile` (`filename`, `contentType`, `content`); clients pass a `File`.
+
+A oneOf is a value that is one of several resources, told apart by a discriminator attribute. Each member resource needs that attribute as a non-nullable enum with a single value:
+
+```yaml
+oneOfs:
+  - name: ViewContent
+    discriminator: kind
+    types: [ChartContent, TableContent]
+resources:
+  - singleName: ChartContent
+    collectionName: ChartContents
+    attributes:
+      - name: kind
+        type: Enum
+        enumValues: [chart]
+```
+
+Fields use it like any other type (`type: ViewContent`, also inside `List` and `Mapping`). `python-server` generates a `ViewContentV1` pydantic discriminated union in `resources`; `typescript-client` generates a `ViewContentV1` union type and a `viewContentV1FromObject` function that builds the member class named by the discriminator (and throws for unknown values).
+
 # Development
 
 ```
@@ -47,8 +88,6 @@ Merges to `main` publish a dev version to PyPI. To release, bump `version` in `p
 
 ## Typing of params and fields in general
 
-Enum and OneOf not supported yet
-
 I think we need to create an object for Type. what would it look like?
 
 

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/README.md

@@ -8,11 +8,52 @@ geniespec watch --spec api.yaml --target <python-server | typescript-client> [--
 ```
 
 - `build` writes the target's package into the output directory. Only files in that package are touched: changed files are rewritten and files it no longer generates are removed.
-  - `python-server`: `./<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`). Code run from the output directory imports it directly, e.g. `from my_service_api.v1 import api`. Needs `kiba-core` (`core.api`, `core.util.typing_util`), `pydantic` and `starlette`.
-  - `typescript-client`: `./<service>-api/v<major>/` (`client`, `endpoints`, `resources`, `index`) with a `<Service>ApiV<major>Client` that extends `@kibalabs/core`'s `ServiceClient`. Construct it with the url the API version is mounted at, e.g. `new MyServiceApiV1Client(requester, 'https://api.example.com/v1')`. Methods take path parameters, then a params object for the request fields, and return the response field; stream transitions take a callback for each item. Transitions with `responseType: redirect` or a `query-parameters` field are left out, as browsers open redirects directly and query-parameters fields receive third-party callbacks. Needs `@kibalabs/core`.
+  - `python-server`: `./<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`). Code run from the output directory imports it directly, e.g. `from my_service_api.v1 import api`. Needs `kiba-core` (`core.api`, `core.util.typing_util`; 0.5.3.dev87 or later for `File` fields), `pydantic` and `starlette`.
+  - `typescript-client`: `./<service>-api/v<major>/` (`client`, `endpoints`, `resources`, `index`) with a `<Service>ApiV<major>Client` that extends `@kibalabs/core`'s `ServiceClient`. Construct it with the url the API version is mounted at, e.g. `new MyServiceApiV1Client(requester, 'https://api.example.com/v1')`. Methods take path parameters, then a params object for the request fields, and return the response field; stream transitions take a callback for each item; transitions with `File` fields send a multipart form. Transitions with `responseType: redirect` or a `query-parameters` field are left out, as browsers open redirects directly and query-parameters fields receive third-party callbacks. Needs `@kibalabs/core`.
 - `watch` builds, then rebuilds whenever the spec changes. If the spec is invalid it logs the error and keeps the previous output. Given a command after `--`, it runs it once the first build is done, keeps rebuilding while it runs, exits with its exit code and stops it when watch itself is stopped, e.g. `geniespec watch --spec api.yaml --target python-server -- uvicorn app:app --reload`.
 - The bundled templates are examples of a kibalabs-style target.
 
+## Enums, oneOfs and files
+
+Enums are string values limited to a list. Name them at the top level to reuse them, or give a field its own:
+
+```yaml
+enums:
+  - name: ViewKind
+    values: [member, cycle-start]
+resources:
+  - singleName: View
+    collectionName: Views
+    attributes:
+      - name: kind
+        type: ViewKind
+      - name: size
+        type: Enum
+        enumValues: [small, large]
+```
+
+`python-server` types them as `typing.Literal[...]` (named ones as `ViewKindV1` in `resources`) and rejects requests with other values; `typescript-client` types them as `'member' | 'cycle-start'` (named ones as an exported `ViewKindV1`).
+
+`type: File` request fields upload a file. They are only allowed on POST transitions, and the transition's other fields must be single primitive or enum values, as the request is sent as a multipart form. Internal methods receive kiba-core's `UploadedFile` (`filename`, `contentType`, `content`); clients pass a `File`.
+
+A oneOf is a value that is one of several resources, told apart by a discriminator attribute. Each member resource needs that attribute as a non-nullable enum with a single value:
+
+```yaml
+oneOfs:
+  - name: ViewContent
+    discriminator: kind
+    types: [ChartContent, TableContent]
+resources:
+  - singleName: ChartContent
+    collectionName: ChartContents
+    attributes:
+      - name: kind
+        type: Enum
+        enumValues: [chart]
+```
+
+Fields use it like any other type (`type: ViewContent`, also inside `List` and `Mapping`). `python-server` generates a `ViewContentV1` pydantic discriminated union in `resources`; `typescript-client` generates a `ViewContentV1` union type and a `viewContentV1FromObject` function that builds the member class named by the discriminator (and throws for unknown values).
+
 # Development
 
 ```
@@ -33,8 +74,6 @@ Merges to `main` publish a dev version to PyPI. To release, bump `version` in `p
 
 ## Typing of params and fields in general
 
-Enum and OneOf not supported yet
-
 I think we need to create an object for Type. what would it look like?
 
 

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "geniespec"
-version = "0.1.1.dev6"
+version = "0.1.1.dev8"
 description = "Generate API code from an api.yaml spec"
 readme = "README.md"
 license = "MIT"
@@ -22,7 +22,7 @@ repository = "https://github.com/kibalabs/genie"
 [dependency-groups]
 dev = [
     "kiba-build==0.1.11.dev15",
-    "kiba-core[core-api,requester]>=0.5.3.dev81,<0.5.4",
+    "kiba-core[core-api,requester]>=0.5.3.dev87,<0.5.4",
 ]
 
 [build-system]

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "geniespec"
-version = "0.1.1.dev6"
+version = "0.1.1.dev8"
 description = "Generate API code from an api.yaml spec"
 readme = "README.md"
 license = "MIT"
@@ -22,7 +22,7 @@ repository = "https://github.com/kibalabs/genie"
 [dependency-groups]
 dev = [
     "kiba-build==0.1.11.dev15",
-    "kiba-core[core-api,requester]>=0.5.3.dev81,<0.5.4",
+    "kiba-core[core-api,requester]>=0.5.3.dev87,<0.5.4",
 ]
 
 [build-system]

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/api_schema.yaml

@@ -32,6 +32,14 @@ properties:
     type: array
     items:
       $ref: '#/definitions/Exception'
+  enums:
+    type: array
+    items:
+      $ref: '#/definitions/Enum'
+  oneOfs:
+    type: array
+    items:
+      $ref: '#/definitions/OneOf'
   imports:
     type: array
     items:
@@ -42,6 +50,46 @@ properties:
       - string
     pattern: '^[a-z][a-z0-9-]*$'
 definitions:
+  EnumValues:
+    type: array
+    minItems: 1
+    uniqueItems: true
+    items:
+      type: string
+      pattern: '^[A-Za-z0-9][A-Za-z0-9_-]*$'
+  Enum:
+    type: object
+    additionalProperties: false
+    required:
+      - name
+      - values
+    properties:
+      name:
+        type: string
+        pattern: '^[A-Z][A-Za-z]*$'
+      values:
+        $ref: '#/definitions/EnumValues'
+  OneOf:
+    type: object
+    additionalProperties: false
+    required:
+      - name
+      - discriminator
+      - types
+    properties:
+      name:
+        type: string
+        pattern: '^[A-Z][A-Za-z]*$'
+      discriminator:
+        type: string
+        pattern: '^[a-z][A-Za-z0-9-]*$'
+      types:
+        type: array
+        minItems: 2
+        uniqueItems: true
+        items:
+          type: string
+          pattern: '^[A-Z][A-Za-z-]*$'
   Attribute:
     type: object
     additionalProperties: false
@@ -93,6 +141,8 @@ definitions:
         items:
           type: string
           pattern: '^[A-Z][A-Za-z-\[\]_, ]*$'
+      enumValues:
+        $ref: '#/definitions/EnumValues'
   Resource:
     type: object
     additionalProperties: false
@@ -221,6 +271,8 @@ definitions:
         items:
           type: string
           pattern: '^[A-Z][A-Za-z-\[\]_, ]*$'
+      enumValues:
+        $ref: '#/definitions/EnumValues'
       isRequired:
         type: boolean
       defaultValue:
@@ -271,6 +323,8 @@ definitions:
         items:
           type: string
           pattern: '^[A-Z][A-Za-z-\[\]_, ]*$'
+      enumValues:
+        $ref: '#/definitions/EnumValues'
       isNullable:
         type: boolean
       isList:

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/genie.py

@@ -24,16 +24,22 @@ from geniespec.renderable_types import ProcessableResource
 from geniespec.renderable_types import RenderableApi
 from geniespec.renderable_types import RenderableAttribute
 from geniespec.renderable_types import RenderableEndpoint
+from geniespec.renderable_types import RenderableEnum
 from geniespec.renderable_types import RenderableException
 from geniespec.renderable_types import RenderableField
 from geniespec.renderable_types import RenderableMethod
+from geniespec.renderable_types import RenderableOneOf
+from geniespec.renderable_types import RenderableOneOfMember
 from geniespec.renderable_types import RenderableOperation
 from geniespec.renderable_types import RenderableParameter
+from geniespec.renderable_types import RenderableRawTypes
 from geniespec.renderable_types import RenderableResource
 from geniespec.renderable_types import RenderableString
 from geniespec.renderable_types import RenderableType
 from geniespec.renderable_types import ResourceEndpointComponent
 from geniespec.renderable_types import SingleResourceEndpointComponent
+from geniespec.types import ApiEnum
+from geniespec.types import ApiOneOf
 from geniespec.types import Attribute
 from geniespec.types import BaseTransition
 from geniespec.types import ComplexTypes
@@ -44,10 +50,12 @@ from geniespec.types import RequestField
 from geniespec.types import Resource
 from geniespec.types import ResponseField
 from geniespec.types import ResponseTypes
+from geniespec.types import SpecialTypes
 
 SCHEMA_FILE_PATH = pathlib.Path(__file__).parent / 'api_schema.yaml'
 TEMPLATES_DIRECTORY_PATH = pathlib.Path(__file__).parent / 'templates'
 TARGET_LANGUAGE_CODES = {'python-server': 'python', 'typescript-client': 'typescript'}
+FORM_FIELD_RAW_TYPES = frozenset({*PrimitiveTypes.ALL, RenderableRawTypes.ENUM, RenderableRawTypes.FILE} - {PrimitiveTypes.JSON})
 
 
 class SyntacticValidationException(BadRequestException):
@@ -106,7 +114,7 @@ class Renderer:
         method = transition.method or defaultMethods.get(transition.action.upper(), 'POST')
         return RenderableMethod(method=RenderableString.from_upper_case_string(string=method))
 
-    def _action_operation(self, transition: BaseTransition, endpoint: RenderableEndpoint, knownTypeNames: set[str], defaultAuthentication: str | None, isIndirectAction: bool = False) -> RenderableOperation:
+    def _action_operation(self, transition: BaseTransition, endpoint: RenderableEndpoint, knownTypeNames: dict[str, str], defaultAuthentication: str | None, isIndirectAction: bool = False) -> RenderableOperation:
         method = self._transition_to_renderable_method(transition=transition)
         fields = [self._request_field_to_renderable_parameter(requestField=requestField, knownTypeNames=knownTypeNames) for requestField in transition.requestFields]
         isQuery = method.method.upperCaseString == 'GET'
@@ -126,38 +134,50 @@ class Renderer:
         rawType: str,
         isNullable: bool,
         isList: bool,
-        knownTypeNames: set[str],
+        knownTypeNames: dict[str, str],
         listValueTypes: list[str] | None = None,
         mappingKeyType: str | None = None,
         mappingValueTypes: list[str] | None = None,
+        enumValues: list[str] | None = None,
     ) -> RenderableType:
         listValueTypes = listValueTypes or []
         mappingValueTypes = mappingValueTypes or []
+        enumValues = enumValues or []
         if rawType == ComplexTypes.MAPPING:
             if mappingKeyType is None or len(mappingValueTypes) == 0:
                 raise KibaException(message='Mapping types require mappingKeyType and mappingValueTypes')
+            if enumValues:
+                raise KibaException(message='Mapping types cannot define enumValues, use a named enum as the value type')
             keyType = self._type_to_renderable_type(rawType=mappingKeyType, isNullable=False, isList=False, knownTypeNames=knownTypeNames)
-            nonNullValueTypes = [valueType for valueType in mappingValueTypes if valueType != 'Null']
+            nonNullValueTypes = [valueType for valueType in mappingValueTypes if valueType != SpecialTypes.NULL]
             if len(nonNullValueTypes) != 1 or len(nonNullValueTypes) - len(mappingValueTypes) not in (0, -1):
                 raise KibaException(message=f'Mapping types currently support one value type with an optional Null: {mappingValueTypes}')
-            valueType = self._type_to_renderable_type(rawType=nonNullValueTypes[0], isNullable='Null' in mappingValueTypes, isList=False, knownTypeNames=knownTypeNames)
+            valueType = self._type_to_renderable_type(rawType=nonNullValueTypes[0], isNullable=SpecialTypes.NULL in mappingValueTypes, isList=False, knownTypeNames=knownTypeNames)
             return MappingRenderableType(isNullable=isNullable, isList=isList, keyType=keyType, valueType=valueType)
-        if rawType == 'List':
+        if rawType == SpecialTypes.LIST:
             if isList or len(listValueTypes) != 1:
                 raise KibaException(message='List types require exactly one listValueTypes entry')
-            itemType = self._type_to_renderable_type(rawType=listValueTypes[0], isNullable=False, isList=False, knownTypeNames=knownTypeNames)
+            itemType = self._type_to_renderable_type(rawType=listValueTypes[0], isNullable=False, isList=False, knownTypeNames=knownTypeNames, enumValues=enumValues)
             if itemType.isList:
                 raise KibaException(message='Nested list types are not supported')
-            return RenderableType(rawType=itemType.rawType, isNullable=isNullable, isList=True, className=itemType.className)
+            return itemType.model_copy(update={'isNullable': isNullable, 'isList': True})
         if listValueTypes:
             raise KibaException(message=f'Only List types may define listValueTypes: {rawType}')
+        if rawType == SpecialTypes.ENUM:
+            if not enumValues:
+                raise KibaException(message='Enum types require enumValues')
+            return RenderableType(rawType=RenderableRawTypes.ENUM, isNullable=isNullable, isList=isList, enumValues=enumValues)
+        if enumValues:
+            raise KibaException(message=f'Only Enum types may define enumValues: {rawType}')
+        if rawType == SpecialTypes.FILE:
+            return RenderableType(rawType=RenderableRawTypes.FILE, isNullable=isNullable, isList=isList)
         if rawType in PrimitiveTypes.ALL:
             return RenderableType(rawType=rawType, isNullable=isNullable, isList=isList)
         if rawType in knownTypeNames:
-            return RenderableType(rawType='class', isNullable=isNullable, className=RenderableString.from_pascal_case_string(string=rawType), isList=isList)
+            return RenderableType(rawType=knownTypeNames[rawType], isNullable=isNullable, className=RenderableString.from_pascal_case_string(string=rawType), isList=isList)
         raise KibaException(message=f'Unknown type: {rawType}')
 
-    def _request_field_to_renderable_parameter(self, requestField: RequestField, knownTypeNames: set[str]) -> RenderableParameter:
+    def _request_field_to_renderable_parameter(self, requestField: RequestField, knownTypeNames: dict[str, str]) -> RenderableParameter:
         return RenderableParameter(
             name=RenderableString.from_kebab_case_string(string=requestField.name),
             fieldType=self._type_to_renderable_type(
@@ -168,6 +188,7 @@ class Renderer:
                 listValueTypes=requestField.listValueTypes,
                 mappingKeyType=requestField.mappingKeyType,
                 mappingValueTypes=requestField.mappingValueTypes,
+                enumValues=requestField.enumValues,
             ),
             defaultValue=requestField.defaultValue,
             maxValue=requestField.maxValue,
@@ -177,7 +198,7 @@ class Renderer:
             source=requestField.source,
         )
 
-    def _response_field_to_renderable_field(self, responseField: ResponseField, knownTypeNames: set[str]) -> RenderableField:
+    def _response_field_to_renderable_field(self, responseField: ResponseField, knownTypeNames: dict[str, str]) -> RenderableField:
         return RenderableField(
             name=RenderableString.from_kebab_case_string(string=responseField.name),
             fieldType=self._type_to_renderable_type(
@@ -188,10 +209,11 @@ class Renderer:
                 listValueTypes=responseField.listValueTypes,
                 mappingKeyType=responseField.mappingKeyType,
                 mappingValueTypes=responseField.mappingValueTypes,
+                enumValues=responseField.enumValues,
             ),
         )
 
-    def _attribute_to_renderable_attribute(self, attribute: Attribute, knownTypeNames: set[str], isNullable: bool | None = None) -> RenderableAttribute:
+    def _attribute_to_renderable_attribute(self, attribute: Attribute, knownTypeNames: dict[str, str], isNullable: bool | None = None) -> RenderableAttribute:
         return RenderableAttribute(
             name=RenderableString.from_kebab_case_string(string=attribute.name),
             fieldType=self._type_to_renderable_type(
@@ -202,6 +224,7 @@ class Renderer:
                 listValueTypes=attribute.listValueTypes,
                 mappingKeyType=attribute.mappingKeyType,
                 mappingValueTypes=attribute.mappingValueTypes,
+                enumValues=attribute.enumValues,
             ),
             defaultValue=attribute.defaultValue,
             isUnique=attribute.isUnique,
@@ -212,11 +235,18 @@ class Renderer:
             isNullable=attribute.isNullable,
         )
 
-    def _attribute_to_renderable_parameter(self, attribute: Attribute, isRequired: bool, knownTypeNames: set[str], shouldUseDefault: bool = True) -> RenderableParameter:
+    def _attribute_to_renderable_parameter(self, attribute: Attribute, isRequired: bool, knownTypeNames: dict[str, str], shouldUseDefault: bool = True) -> RenderableParameter:
         return RenderableParameter(
             name=RenderableString.from_kebab_case_string(string=attribute.name),
             fieldType=self._type_to_renderable_type(
-                rawType=attribute.fieldType, isNullable=attribute.isNullable, isList=False, knownTypeNames=knownTypeNames, listValueTypes=attribute.listValueTypes, mappingKeyType=attribute.mappingKeyType, mappingValueTypes=attribute.mappingValueTypes
+                rawType=attribute.fieldType,
+                isNullable=attribute.isNullable,
+                isList=False,
+                knownTypeNames=knownTypeNames,
+                listValueTypes=attribute.listValueTypes,
+                mappingKeyType=attribute.mappingKeyType,
+                mappingValueTypes=attribute.mappingValueTypes,
+                enumValues=attribute.enumValues,
             ),
             defaultValue=attribute.defaultValue if shouldUseDefault else None,
             isRequired=isRequired,
@@ -227,7 +257,7 @@ class Renderer:
     def _resource_full_name(resource: Resource, name: str) -> str:
         return f'{resource.parentResource or ""}{name}'
 
-    def _resource_to_renderable_resource(self, resource: Resource, knownTypeNames: set[str]) -> RenderableResource:
+    def _resource_to_renderable_resource(self, resource: Resource, knownTypeNames: dict[str, str]) -> RenderableResource:
         attributes = [self._attribute_to_renderable_attribute(attribute=attribute, knownTypeNames=knownTypeNames) for attribute in resource.attributes]
         return RenderableResource(
             singleName=RenderableString.from_pascal_case_string(string=self._resource_full_name(resource=resource, name=resource.singleName)),
@@ -239,7 +269,7 @@ class Renderer:
             accessibleFrom=resource.accessibleFrom,
         )
 
-    def _get_processable_resource(self, renderableResource: RenderableResource, allResources: list[RenderableResource], knownTypeNames: set[str]) -> ProcessableResource:
+    def _get_processable_resource(self, renderableResource: RenderableResource, allResources: list[RenderableResource], knownTypeNames: dict[str, str]) -> ProcessableResource:
         parent: ProcessableResource.Parent | None = None
         attributeOccurrences: list[ProcessableResource.IndependentAttributeOccurrence] = []
         parentResource = next(iter([otherResource for otherResource in allResources if renderableResource.parentResource and otherResource.singleName.pascalCaseString == renderableResource.parentResource]), None)
@@ -249,7 +279,7 @@ class Renderer:
             parent = ProcessableResource.Parent(processableResource=parentProcessableResource, isOneToOne=isOneToOne)
         for otherResource in allResources:
             for attribute in otherResource.independentAttributes:
-                if attribute.fieldType.rawType == 'class' and attribute.fieldType.className == renderableResource.singleName:
+                if attribute.fieldType.rawType == RenderableRawTypes.CLASS and attribute.fieldType.className == renderableResource.singleName:
                     occursInResource = self._get_processable_resource(renderableResource=otherResource, allResources=allResources, knownTypeNames=knownTypeNames)
                     occursInAttribute = attribute
                     attributeOccurrences.append(ProcessableResource.IndependentAttributeOccurrence(processableResource=occursInResource, attribute=occursInAttribute))
@@ -328,14 +358,68 @@ class Renderer:
             errors.append(f'{name}: stream transitions need a responseField')
         if operation.responseType == ResponseTypes.REDIRECT and operation.responseFields:
             errors.append(f'{name}: redirect transitions cannot have a responseField')
+        errors += [f'{name}: response field {field.name.kebabCaseString} cannot be a File' for field in operation.responseFields or [] if field.fieldType.rawType == RenderableRawTypes.FILE]
+        if any(parameter.fieldType.rawType == RenderableRawTypes.FILE for parameter in operation.parameters):
+            if operation.method.method.upperCaseString != 'POST':
+                errors.append(f'{name}: only POST transitions can have File fields')
+            if operation.responseType == ResponseTypes.STREAM:
+                errors.append(f'{name}: stream transitions cannot have File fields')
+            errors += [
+                f'{name}: field {parameter.name.kebabCaseString} cannot be sent with File fields, only single primitive, enum and File values can'
+                for parameter in operation.parameters
+                if parameter.source == FieldSources.REQUEST and (parameter.fieldType.isList or isinstance(parameter.fieldType, MappingRenderableType) or parameter.fieldType.rawType not in FORM_FIELD_RAW_TYPES)
+            ]
         return errors
 
+    @staticmethod
+    def _file_errors(resources: list[RenderableResource], exceptions: list[RenderableException]) -> list[str]:
+        errors = [
+            f'Attribute {attribute.name.kebabCaseString} of {resource.singleName.pascalCaseString} cannot be a File'
+            for resource in resources
+            for attribute in [*resource.attributes, *resource.independentAttributes]
+            if attribute.fieldType.rawType == RenderableRawTypes.FILE
+        ]
+        errors += [f'Field {field.name.snakeCaseString} of {exception.name.pascalCaseString} cannot be a File' for exception in exceptions for field in exception.fields if field.fieldType.rawType == RenderableRawTypes.FILE]
+        return errors
+
+    @staticmethod
+    def _one_of_members(oneOf: ApiOneOf, resourcesByName: dict[str, Resource], enumsByName: dict[str, ApiEnum]) -> tuple[list[RenderableOneOfMember], list[str]]:
+        members: list[RenderableOneOfMember] = []
+        errors: list[str] = []
+        for typeName in oneOf.types:
+            resource = resourcesByName.get(typeName)
+            if resource is None:
+                errors.append(f'Unknown resource {typeName} in {oneOf.name}')
+                continue
+            attribute = next((attribute for attribute in resource.attributes if attribute.name == oneOf.discriminator), None)
+            if attribute is None:
+                errors.append(f'{typeName} needs a {oneOf.discriminator} attribute to be part of {oneOf.name}')
+                continue
+            values = attribute.enumValues if attribute.fieldType == SpecialTypes.ENUM else enumsByName[attribute.fieldType].values if attribute.fieldType in enumsByName else []
+            if len(values) != 1 or attribute.isNullable:
+                errors.append(f'{oneOf.discriminator} of {typeName} must be a non-nullable Enum with one value to be part of {oneOf.name}')
+                continue
+            members.append(RenderableOneOfMember(className=RenderableString.from_pascal_case_string(string=typeName), value=values[0]))
+        errors += [f'{oneOf.name} has more than one {oneOf.discriminator} {value}' for value, count in collections.Counter(member.value for member in members).items() if count > 1]
+        return members, errors
+
     def build_renderable_api(self, api: KibaApi) -> RenderableApi:
         fullResourceNames = [self._resource_full_name(resource=resource, name=resource.singleName) for resource in api.resources]
-        knownTypeNames = set(fullResourceNames)
-        resourceErrors = [f'Duplicate resource name: {name}' for name, count in collections.Counter(fullResourceNames).items() if count > 1]
-        resourceErrors += [f'Unknown parent resource {resource.parentResource} for {resource.singleName}' for resource in api.resources if resource.parentResource is not None and resource.parentResource not in knownTypeNames]
+        enumNames = [enum.name for enum in api.enums]
+        oneOfNames = [oneOf.name for oneOf in api.oneOfs]
+        knownTypeNames = {
+            **dict.fromkeys(fullResourceNames, RenderableRawTypes.CLASS),
+            **dict.fromkeys(enumNames, RenderableRawTypes.ENUM),
+            **dict.fromkeys(oneOfNames, RenderableRawTypes.ONE_OF),
+        }
+        resourceErrors = [f'Duplicate type name: {name}' for name, count in collections.Counter(fullResourceNames + enumNames + oneOfNames).items() if count > 1]
+        resourceErrors += [f'Unknown parent resource {resource.parentResource} for {resource.singleName}' for resource in api.resources if resource.parentResource is not None and resource.parentResource not in fullResourceNames]
         resourcesByName = dict(zip(fullResourceNames, api.resources, strict=False))
+        renderableOneOfs: list[RenderableOneOf] = []
+        for oneOf in api.oneOfs:
+            members, oneOfErrors = self._one_of_members(oneOf=oneOf, resourcesByName=resourcesByName, enumsByName={enum.name: enum for enum in api.enums})
+            resourceErrors += oneOfErrors
+            renderableOneOfs.append(RenderableOneOf(name=RenderableString.from_pascal_case_string(string=oneOf.name), discriminator=RenderableString.from_kebab_case_string(string=oneOf.discriminator), members=members))
         for resource, fullName in zip(api.resources, fullResourceNames, strict=True):
             ancestorNames: list[str] = []
             ancestor = resourcesByName.get(resource.parentResource) if resource.parentResource is not None else None
@@ -389,6 +473,8 @@ class Renderer:
             resources=[],
             operations=renderableOperations,
             exceptions=renderableExceptions,
+            enums=[RenderableEnum(name=RenderableString.from_pascal_case_string(string=enum.name), values=enum.values) for enum in api.enums],
+            oneOfs=renderableOneOfs,
         )
         renderableResources: list[RenderableResource] = [self._resource_to_renderable_resource(resource=resource, knownTypeNames=knownTypeNames) for resource in api.resources]
         uncoveredTransitions: list[str] = []
@@ -466,6 +552,7 @@ class Renderer:
                 message=f'Transitions with no endpoint: {", ".join(uncoveredTransitions)}. Item transitions need a primary attribute, collection transitions need direct access or a parent resource, and CREATE is not supported on one-to-one child resources.'
             )
         operationErrors = [error for operation in renderableApi.operations for error in self._operation_errors(operation=operation)]
+        operationErrors += self._file_errors(resources=renderableResources, exceptions=renderableExceptions)
         if operationErrors:
             raise SemanticValidationException(message='\n'.join(operationErrors))
         renderableApi.resources.extend(renderableResources)

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/languages.py

@@ -9,10 +9,13 @@ from geniespec.renderable_types import AttributeEndpointComponent
 from geniespec.renderable_types import MappingRenderableType
 from geniespec.renderable_types import RenderableApi
 from geniespec.renderable_types import RenderableEndpointComponent
+from geniespec.renderable_types import RenderableEnum
 from geniespec.renderable_types import RenderableException
 from geniespec.renderable_types import RenderableField
+from geniespec.renderable_types import RenderableOneOf
 from geniespec.renderable_types import RenderableOperation
 from geniespec.renderable_types import RenderableParameter
+from geniespec.renderable_types import RenderableRawTypes
 from geniespec.renderable_types import RenderableResource
 from geniespec.renderable_types import RenderableString
 from geniespec.renderable_types import RenderableType
@@ -66,13 +69,13 @@ class BaseLanguageDefinition:
     def object_type(self, isNullable: bool, className: RenderableString, apiVersion: Version, isLocalReference: bool) -> str:
         raise NotImplementedError
 
-    def one_of_type(self, isNullable: bool, subTypes: list[str]) -> str:
+    def string_type(self, isNullable: bool) -> str:
         raise NotImplementedError
 
-    def string_type(self, isNullable: bool) -> str:
+    def enum_type(self, isNullable: bool, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool) -> str:
         raise NotImplementedError
 
-    def enum_type(self, isNullable: bool, values: list[str]) -> str:
+    def file_type(self, isNullable: bool) -> str:
         raise NotImplementedError
 
     def package_name(self, api: RenderableApi) -> str:
@@ -87,10 +90,6 @@ class BaseLanguageDefinition:
     def is_valid_name(self, name: str) -> bool:
         raise NotImplementedError
 
-    def _render_one_of_type_string(self, oneOfTypeString: str, isNullable: bool, apiVersion: Version) -> list[str]:
-        oneOfTypes = ''.join(oneOfTypeString.replace('OneOf[', '', 1).rsplit(']', 1)).split(', ')
-        return [self.render_type(renderableType=RenderableType(rawType=oneOfType, isNullable=isNullable), apiVersion=apiVersion) for oneOfType in oneOfTypes]
-
     def _render_list_type_string(self, listTypeString: str, apiVersion: Version) -> str:
         listItemType = ''.join(listTypeString.replace('List[', '', 1).rsplit(']', 1))
         return self.render_type(renderableType=RenderableType(rawType=listItemType, isNullable=False), apiVersion=apiVersion)
@@ -118,19 +117,15 @@ class BaseLanguageDefinition:
             return self.date_type(isNullable=isNullable)
         if yamlType == PrimitiveTypes.JSON:
             return self.json_type(isNullable=isNullable)
-        # if yamlType == PrimitiveTypes.STRUCT:
-        #     return self.struct_type(isNullable=isNullable)
-        # if yamlType.startswith(PrimitiveTypes.ENUM):
-        #     values = ''.join(yamlType.replace('Enum[', '', 1).rsplit(']', 1)).split(', ')
-        #     return self.enum_type(isNullable=isNullable, values=[RenderableString.from_kebab_case_string(string=value) for value in values])
-        # if yamlType.startswith(PrimitiveTypes.ONE_OF):
-        #     subTypes = self._render_one_of_type_string(oneOfTypeString=yamlType, isNullable=isNullable, apiVersion=apiVersion)
-        #     return self.one_of_type(isNullable=isNullable, subTypes=subTypes)
+        if yamlType == RenderableRawTypes.ENUM:
+            return self.enum_type(isNullable=isNullable, renderableType=renderableType, apiVersion=apiVersion, isLocalReference=isLocalReference)
+        if yamlType == RenderableRawTypes.FILE:
+            return self.file_type(isNullable=isNullable)
         if yamlType == ComplexTypes.MAPPING and isinstance(renderableType, MappingRenderableType):
             keyType = self.render_type(renderableType=renderableType.keyType, apiVersion=apiVersion, isLocalReference=isLocalReference)
             valueType = self.render_type(renderableType=renderableType.valueType, apiVersion=apiVersion, isLocalReference=isLocalReference)
             return self.mapping_type(isNullable=isNullable, keyType=keyType, valueType=valueType)
-        if yamlType == 'class' and isinstance(renderableType, RenderableType) and renderableType.className is not None:
+        if yamlType in (RenderableRawTypes.CLASS, RenderableRawTypes.ONE_OF) and renderableType.className is not None:
             return self.object_type(isNullable=isNullable, className=renderableType.className, apiVersion=apiVersion, isLocalReference=isLocalReference)
         raise KibaException(f'Failed to render: {type(renderableType)} {renderableType}')
 
@@ -171,6 +166,23 @@ class BaseLanguageDefinition:
     def exception_class_name(self, exception: RenderableException, apiVersion: Version) -> str:
         return f'{self.pascal_name(name=exception.name)}V{apiVersion.major}'
 
+    def enum_class_name(self, enum: RenderableEnum, apiVersion: Version) -> str:
+        return f'{self.pascal_name(name=enum.name)}V{apiVersion.major}'
+
+    def one_of_class_name(self, oneOf: RenderableOneOf, apiVersion: Version) -> str:
+        return f'{self.pascal_name(name=oneOf.name)}V{apiVersion.major}'
+
+    def one_of_member_class_names(self, oneOf: RenderableOneOf, apiVersion: Version) -> list[str]:
+        return [f'{self.pascal_name(name=member.className)}V{apiVersion.major}' for member in oneOf.members]
+
+    @staticmethod
+    def is_inline_enum(renderableType: RenderableType) -> bool:
+        return renderableType.rawType == RenderableRawTypes.ENUM and renderableType.className is None
+
+    @staticmethod
+    def is_file_operation(operation: RenderableOperation) -> bool:
+        return any(parameter.fieldType.rawType == RenderableRawTypes.FILE for parameter in operation.parameters)
+
     def type(self, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool = False) -> str:
         return self.render_type(renderableType=renderableType, apiVersion=apiVersion, isLocalReference=isLocalReference)
 
@@ -327,16 +339,22 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
         typeName = f'{className.pascalCaseString}V{apiVersion.major}' if isLocalReference else f'resources.{className.pascalCaseString}V{apiVersion.major}'
         return f'{typeName} | None' if isNullable else typeName
 
-    def one_of_type(self, isNullable: bool, subTypes: list[str]) -> str:
-        fieldTypes = ' | '.join(subTypes)
-        return f'{fieldTypes} | None' if isNullable else f'Union[{fieldTypes} | None'
-
     def string_type(self, isNullable: bool) -> str:
         return 'str | None' if isNullable else 'str'
 
-    def enum_type(self, isNullable: bool, values: list[str]) -> str:
-        valueString = ', '.join([f"'{value}'" for value in values])
-        return f'typing.Literal[{valueString}] | None' if isNullable else f'Literal[{valueString} | None'
+    def enum_type(self, isNullable: bool, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool) -> str:
+        if renderableType.className is None:
+            typeName = self.enum_literal(values=renderableType.enumValues)
+        else:
+            typeName = f'{renderableType.className.pascalCaseString}V{apiVersion.major}' if isLocalReference else f'resources.{renderableType.className.pascalCaseString}V{apiVersion.major}'
+        return f'{typeName} | None' if isNullable else typeName
+
+    @staticmethod
+    def enum_literal(values: list[str]) -> str:
+        return f'typing.Literal[{", ".join(repr(value) for value in values)}]'
+
+    def file_type(self, isNullable: bool) -> str:
+        return 'UploadedFile | None' if isNullable else 'UploadedFile'
 
     def package_name(self, api: RenderableApi) -> str:
         return f'{self.snake_name(name=api.serviceName)}_api'
@@ -393,6 +411,19 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def resources_require_json(self, api: RenderableApi) -> bool:
         return any(self._contains_json(renderableType=attribute.fieldType) for resource in api.resources for attribute in resource.attributes)
 
+    def resources_require_typing(self, api: RenderableApi) -> bool:
+        return len(api.enums) > 0 or len(api.oneOfs) > 0 or any(self.is_inline_enum(renderableType=attribute.fieldType) for resource in api.resources for attribute in resource.attributes)
+
+    def one_of_alias(self, oneOf: RenderableOneOf, apiVersion: Version) -> str:
+        return f'typing.Annotated[{" | ".join(self.one_of_member_class_names(oneOf=oneOf, apiVersion=apiVersion))}, pydantic.Field(discriminator={self.identifier(name=oneOf.discriminator)!r})]'
+
+    def operations_require_typing(self, api: RenderableApi) -> bool:
+        fieldTypes = [parameter.fieldType for operation in api.operations for parameter in operation.parameters] + [field.fieldType for operation in api.operations for field in operation.responseFields or []]
+        return any(self.is_inline_enum(renderableType=fieldType) for fieldType in fieldTypes)
+
+    def requires_uploaded_file(self, api: RenderableApi) -> bool:
+        return any(self.is_file_operation(operation=operation) for operation in api.operations)
+
     def operations_require_json(self, api: RenderableApi) -> bool:
         fieldTypes = [parameter.fieldType for operation in api.operations for parameter in operation.parameters] + [field.fieldType for operation in api.operations for field in operation.responseFields or []]
         return any(self._contains_json(renderableType=fieldType) for fieldType in fieldTypes)
@@ -516,6 +547,19 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
     def string_type(self, isNullable: bool) -> str:
         return self._nullable(typeName='string', isNullable=isNullable)
 
+    def enum_type(self, isNullable: bool, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool) -> str:
+        if renderableType.className is None:
+            return self._nullable(typeName=f'({self.enum_union(values=renderableType.enumValues)})', isNullable=isNullable)
+        typeName = f'{renderableType.className.pascalCaseString}V{apiVersion.major}'
+        return self._nullable(typeName=typeName if isLocalReference else f'Resources.{typeName}', isNullable=isNullable)
+
+    @staticmethod
+    def enum_union(values: list[str]) -> str:
+        return ' | '.join(f"'{value}'" for value in values)
+
+    def file_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='File', isNullable=isNullable)
+
     def package_name(self, api: RenderableApi) -> str:
         return f'{self.kebab_name(name=api.serviceName)}-api'
 
@@ -566,7 +610,14 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
         return f'on{self.pascal_name(name=responseField.name)}'
 
     def references_resources(self, renderableTypes: list[RenderableType]) -> bool:
-        return any(self._contains_raw_type(renderableType=renderableType, rawType=rawType) for renderableType in renderableTypes for rawType in ('class', PrimitiveTypes.JSON))
+        valueTypes = [self._value_type(renderableType=renderableType) for renderableType in renderableTypes]
+        return any(valueType.rawType in ('class', PrimitiveTypes.JSON, RenderableRawTypes.ONE_OF) or (valueType.rawType == RenderableRawTypes.ENUM and valueType.className is not None) for valueType in valueTypes)
+
+    def one_of_parser_name(self, name: RenderableString, apiVersion: Version) -> str:
+        return f'{self._normalized_name(name=name).camelCaseString}V{apiVersion.major}FromObject'
+
+    def _value_type(self, renderableType: RenderableType) -> RenderableType:
+        return self._value_type(renderableType=renderableType.valueType) if isinstance(renderableType, MappingRenderableType) else renderableType
 
     def requires_date_parsing(self, renderableTypes: list[RenderableType]) -> bool:
         return any(self._contains_raw_type(renderableType=renderableType, rawType=rawType) for renderableType in renderableTypes for rawType in (PrimitiveTypes.DATE, PrimitiveTypes.DATETIME))
@@ -580,6 +631,18 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
     def body_parameter_types(self, api: RenderableApi) -> list[RenderableType]:
         return [parameter.fieldType for operation in self.client_operations(api=api) for parameter in self.body_parameters(operation=operation)]
 
+    def requires_request_data(self, api: RenderableApi) -> bool:
+        return any(self.body_parameters(operation=operation) and not self.is_file_operation(operation=operation) for operation in self.client_operations(api=api))
+
+    def form_value(self, renderableType: RenderableType, value: str) -> str:
+        if renderableType.rawType == RenderableRawTypes.FILE:
+            return value
+        if renderableType.rawType == PrimitiveTypes.DATETIME:
+            return f'dateToString({value})'
+        if renderableType.rawType == PrimitiveTypes.DATE:
+            return f"dateToString({value}, 'yyyy-MM-dd')"
+        return f'String({value})'
+
     def _contains_raw_type(self, renderableType: RenderableType, rawType: str) -> bool:
         if isinstance(renderableType, MappingRenderableType):
             return self._contains_raw_type(renderableType=renderableType.valueType, rawType=rawType)
@@ -597,6 +660,9 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
             valueTypeName = self.type(renderableType=renderableType.valueType, apiVersion=apiVersion, isLocalReference=isLocalReference)
             convertedEntry = self.from_object(renderableType=renderableType.valueType, value='entry', apiVersion=apiVersion, isLocalReference=isLocalReference)
             return f'Object.fromEntries(Object.entries({value} as RawObject).map(([key, entry]: [string, unknown]): [string, {valueTypeName}] => [key, {convertedEntry}]))'
+        if renderableType.rawType == RenderableRawTypes.ONE_OF and renderableType.className is not None:
+            parserName = self.one_of_parser_name(name=renderableType.className, apiVersion=apiVersion)
+            return f'{parserName if isLocalReference else f"Resources.{parserName}"}({value} as RawObject)'
         if renderableType.rawType == 'class' and renderableType.className is not None:
             return f'{self.type(renderableType=renderableType, apiVersion=apiVersion, isLocalReference=isLocalReference)}.fromObject({value} as RawObject)'
         if renderableType.rawType == PrimitiveTypes.STRING:
@@ -609,12 +675,14 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
             return f'dateFromString(String({value}))'
         if renderableType.rawType == PrimitiveTypes.JSON:
             return f'{value} as {self.type(renderableType=renderableType, apiVersion=apiVersion, isLocalReference=isLocalReference)}'
+        if renderableType.rawType == RenderableRawTypes.ENUM:
+            return f'String({value}) as {self.type(renderableType=renderableType, apiVersion=apiVersion, isLocalReference=isLocalReference)}'
         raise KibaException(f'Failed to render conversion from object for: {renderableType}')
 
     def _is_serialized_as_is(self, renderableType: RenderableType) -> bool:
         if isinstance(renderableType, MappingRenderableType):
             return self._is_serialized_as_is(renderableType=renderableType.valueType)
-        return renderableType.rawType not in ('class', PrimitiveTypes.DATE, PrimitiveTypes.DATETIME)
+        return renderableType.rawType not in ('class', RenderableRawTypes.ONE_OF, PrimitiveTypes.DATE, PrimitiveTypes.DATETIME)
 
     def to_object(self, renderableType: RenderableType, value: str, apiVersion: Version, isOptional: bool = False, isLocalReference: bool = False) -> str:
         if self._is_serialized_as_is(renderableType=renderableType):
@@ -630,7 +698,7 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
             valueTypeName = self.type(renderableType=renderableType.valueType, apiVersion=apiVersion, isLocalReference=isLocalReference)
             convertedEntry = self.to_object(renderableType=renderableType.valueType, value='entry', apiVersion=apiVersion, isLocalReference=isLocalReference)
             return f'Object.fromEntries(Object.entries({value}).map(([key, entry]: [string, {valueTypeName}]): [string, unknown] => [key, {convertedEntry}]))'
-        if renderableType.rawType == 'class':
+        if renderableType.rawType in ('class', RenderableRawTypes.ONE_OF):
             return f'{value}.toObject()'
         if renderableType.rawType == PrimitiveTypes.DATETIME:
             return f'dateToString({value})'

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/renderable_types.py

@@ -87,11 +87,35 @@ class RenderableString(BaseModel):
         return cls(string=string.split(separator))
 
 
+class RenderableRawTypes:
+    CLASS = 'class'
+    ENUM = 'enum'
+    FILE = 'file'
+    ONE_OF = 'oneOf'
+
+
 class RenderableType(BaseModel):
     rawType: str
     isNullable: bool
     isList: bool = False
     className: RenderableString | None = None
+    enumValues: list[str] = []
+
+
+class RenderableEnum(BaseModel):
+    name: RenderableString
+    values: list[str]
+
+
+class RenderableOneOfMember(BaseModel):
+    className: RenderableString
+    value: str
+
+
+class RenderableOneOf(BaseModel):
+    name: RenderableString
+    discriminator: RenderableString
+    members: list[RenderableOneOfMember]
 
 
 class MappingRenderableType(RenderableType):
@@ -225,6 +249,8 @@ class RenderableApi(BaseModel):
     resources: list[RenderableResource]
     operations: list[RenderableOperation]
     exceptions: list[RenderableException]
+    enums: list[RenderableEnum] = []
+    oneOfs: list[RenderableOneOf] = []
 
 
 class ProcessableResource(BaseModel):

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/templates/python-server/{service}/v{version}/endpoints.py.j2

@@ -1,7 +1,7 @@
 {{ autogenerated_notice }}
 import collections.abc
 import datetime
-{% if target.requires_optional_field_default(api=api) %}
+{% if target.requires_optional_field_default(api=api) or target.operations_require_typing(api=api) %}
 import typing
 {% endif %}
 
@@ -16,6 +16,9 @@ from pydantic import BaseModel
 {% if target.requires_undefined(api=api) %}
 from core.util.typing_util import UNDEFINED, UpdateValue
 {% endif %}
+{% if target.requires_uploaded_file(api=api) %}
+from core.api.uploaded_file import UploadedFile
+{% endif %}
 
 from . import resources
 

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/templates/python-server/{service}/v{version}/internal.py.j2

@@ -2,6 +2,9 @@
 import abc
 import datetime
 import collections.abc
+{% if target.operations_require_typing(api=api) %}
+import typing
+{% endif %}
 
 {% if target.operations_require_json(api=api) %}
 import pydantic
@@ -11,6 +14,9 @@ from . import resources
 {% if target.requires_undefined(api=api) %}
 from core.util.typing_util import UNDEFINED, UpdateValue
 {% endif %}
+{% if target.requires_uploaded_file(api=api) %}
+from core.api.uploaded_file import UploadedFile
+{% endif %}
 
 
 class {{ target.internal_class_name(api=api) }}(abc.ABC):

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/templates/python-server/{service}/v{version}/resources.py.j2

@@ -3,12 +3,21 @@ from __future__ import annotations
 
 import collections.abc
 import datetime
+{% if target.resources_require_typing(api=api) %}
+import typing
+{% endif %}
 
-{% if target.resources_require_json(api=api) %}
+{% if target.resources_require_json(api=api) or api.oneOfs %}
 import pydantic
 {% endif %}
 from pydantic import BaseModel
 
+{% for enum in api.enums %}
+{{ target.enum_class_name(enum=enum, apiVersion=api.version) }} = {{ target.enum_literal(values=enum.values) }}
+{% if loop.last %}
+
+{% endif %}
+{% endfor %}
 {% for resource in api.resources %}
 
 class {{ target.resource_class_name(resource=resource, apiVersion=api.version) }}(BaseModel):
@@ -20,3 +29,9 @@ class {{ target.resource_class_name(resource=resource, apiVersion=api.version) }
 {% endfor %}
 
 {% endfor %}
+{% for oneOf in api.oneOfs %}
+{% if loop.first %}
+
+{% endif %}
+{{ target.one_of_class_name(oneOf=oneOf, apiVersion=api.version) }} = {{ target.one_of_alias(oneOf=oneOf, apiVersion=api.version) }}
+{% endfor %}

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/templates/typescript-client/{service}/v{version}/client.ts.j2

@@ -21,7 +21,14 @@ export class {{ target.client_class_name(api=api) }} extends ServiceClient {
 {% if not loop.first %}
 
 {% endif %}
-{% if target.is_streaming(operation=operation) %}
+{% if target.is_file_operation(operation=operation) %}
+  public {{ target.operation_name(operation=operation) }} = async ({{ arguments | join(', ') }}): Promise<{{ target.type(renderableType=responseField.fieldType, apiVersion=api.version) if responseField else 'void' }}> => {
+    {% if responseField %}const response = {% endif %}await this.requester.makeFormRequest(`${this.baseUrl}/{{ path }}`, {{ request }}.toFormData());
+{% if responseField %}
+    return Endpoints.{{ className }}Response.fromObject(JSON.parse(response.content)).{{ target.identifier(name=responseField.name) }};
+{% endif %}
+  };
+{% elif target.is_streaming(operation=operation) %}
   public {{ target.operation_name(operation=operation) }} = async ({{ arguments | join(', ') }}): Promise<void> => {
     await this.makeStreamingRequest(RestMethod.{{ target.http_method(operation=operation) }}, {{ pathLiteral }}, {{ request }}, Endpoints.{{ className }}Response, (response: Endpoints.{{ className }}Response): void => {
       {{ target.stream_callback_name(operation=operation) }}(response.{{ target.identifier(name=responseField.name) }});

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/templates/typescript-client/{service}/v{version}/endpoints.ts.j2

@@ -5,7 +5,7 @@
 {% if target.requires_date_parsing(renderableTypes=responseTypes) %}{% set _ = coreImports.append('dateFromString') %}{% endif %}
 {% if target.requires_date_parsing(renderableTypes=bodyTypes) %}{% set _ = coreImports.append('dateToString') %}{% endif %}
 {% set _ = coreImports.append('RawObject') %}
-{% if bodyTypes %}{% set _ = coreImports.append('RequestData') %}{% endif %}
+{% if target.requires_request_data(api=api) %}{% set _ = coreImports.append('RequestData') %}{% endif %}
 {% if responseTypes %}{% set _ = coreImports.append('ResponseData') %}{% endif %}
 import { {{ coreImports | join(', ') }} } from '@kibalabs/core';
 {% if target.references_resources(renderableTypes=responseTypes + bodyTypes) %}
@@ -24,6 +24,29 @@ export interface {{ className }}Params {
 {% endfor %}
 }
 
+{% if target.is_file_operation(operation=operation) %}
+export class {{ className }}Request {
+  public constructor(
+    readonly params: {{ className }}Params,
+  ) { }
+
+  public toFormData = (): FormData => {
+    const formData = new FormData();
+{% for parameter in bodyParameters %}
+{% set parameterName = target.identifier(name=parameter.name) %}
+{% set value = 'this.params.' ~ parameterName %}
+{% if target.is_parameter_required(operation=operation, parameter=parameter) and not target.parameter_field_type(operation=operation, parameter=parameter).isNullable %}
+    formData.append('{{ parameterName }}', {{ target.form_value(renderableType=parameter.fieldType, value=value) }});
+{% else %}
+    if ({{ value }} != null) {
+      formData.append('{{ parameterName }}', {{ target.form_value(renderableType=parameter.fieldType, value=value) }});
+    }
+{% endif %}
+{% endfor %}
+    return formData;
+  };
+}
+{% else %}
 export class {{ className }}Request extends RequestData {
   public constructor(
     readonly params: {{ className }}Params,
@@ -40,6 +63,7 @@ export class {{ className }}Request extends RequestData {
   };
 }
 {% endif %}
+{% endif %}
 {% if responseField %}
 
 export class {{ className }}Response extends ResponseData {

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/templates/typescript-client/{service}/v{version}/resources.ts.j2

@@ -6,6 +6,10 @@ import { RawObject } from '@kibalabs/core';
 {% endif %}
 
 export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
+{% for enum in api.enums %}
+
+export type {{ target.enum_class_name(enum=enum, apiVersion=api.version) }} = {{ target.enum_union(values=enum.values) }};
+{% endfor %}
 {% for resource in api.resources %}
 {% set className = target.resource_class_name(resource=resource, apiVersion=api.version) %}
 
@@ -43,3 +47,20 @@ export class {{ className }} {
 {% endif %}
 }
 {% endfor %}
+{% for oneOf in api.oneOfs %}
+{% set typeName = target.one_of_class_name(oneOf=oneOf, apiVersion=api.version) %}
+{% set discriminator = target.identifier(name=oneOf.discriminator) %}
+
+export type {{ typeName }} = {{ target.one_of_member_class_names(oneOf=oneOf, apiVersion=api.version) | join(' | ') }};
+
+export const {{ target.one_of_parser_name(name=oneOf.name, apiVersion=api.version) }} = (obj: RawObject): {{ typeName }} => {
+  switch (obj.{{ discriminator }}) {
+{% for member in oneOf.members %}
+    case '{{ member.value }}':
+      return {{ target.one_of_member_class_names(oneOf=oneOf, apiVersion=api.version)[loop.index0] }}.fromObject(obj);
+{% endfor %}
+    default:
+      throw new Error(`Unknown {{ typeName }} {{ discriminator }}: ${String(obj.{{ discriminator }})}`);
+  }
+};
+{% endfor %}

{geniespec-0.1.1.dev6 → geniespec-0.1.1.dev8}/src/geniespec/types.py

@@ -35,12 +35,31 @@ class ComplexTypes:
     ALL: ClassVar[list[str]] = [MAPPING]
 
 
+class SpecialTypes:
+    LIST = 'List'
+    ENUM = 'Enum'
+    FILE = 'File'
+    NULL = 'Null'
+
+
+class ApiEnum(BaseModel):
+    name: str
+    values: list[str]
+
+
+class ApiOneOf(BaseModel):
+    name: str
+    discriminator: str
+    types: list[str]
+
+
 class Attribute(BaseModel):
     name: str
     fieldType: str = pydantic.Field(alias='type')
     listValueTypes: list[str] = []
     mappingKeyType: str | None = None
     mappingValueTypes: list[str] = []
+    enumValues: list[str] = []
     isPrimary: bool = False
     isUnique: bool = False
     shouldDisableGetEndpoint: bool = False
@@ -59,6 +78,7 @@ class ResponseField(BaseModel):
     listValueTypes: list[str] = []
     mappingKeyType: str | None = None
     mappingValueTypes: list[str] = []
+    enumValues: list[str] = []
     isNullable: bool = False
     isList: bool = False
 
@@ -69,6 +89,7 @@ class RequestField(BaseModel):
     listValueTypes: list[str] = []
     mappingKeyType: str | None = None
     mappingValueTypes: list[str] = []
+    enumValues: list[str] = []
     isRequired: bool = False
     isDeprecated: bool = False
     defaultValue: str | int | float | bool | None = None
@@ -139,6 +160,8 @@ class KibaApi(BaseModel):
     resources: list[Resource] = []
     transitions: list[RootTransition] = []
     exceptions: list[ApiException] = []
+    enums: list[ApiEnum] = []
+    oneOfs: list[ApiOneOf] = []
     defaultAuthentication: str | None = None
 
     @property