geniespec 0.1.1.dev5__tar.gz → 0.1.1.dev7__tar.gz

{geniespec-0.1.1.dev5 → geniespec-0.1.1.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geniespec
-Version: 0.1.1.dev5
+Version: 0.1.1.dev7
 Summary: Generate API code from an api.yaml spec
 License-Expression: MIT
 Requires-Dist: jinja2>=3.1.6
@@ -22,11 +22,34 @@ 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 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`.
+
 # Development
 
 ```
@@ -34,13 +57,20 @@ make install
 make lint-check type-check test
 ```
 
+`tests/python_server` covers the core and the `python-server` target (the core tests generate through it) and runs in `Dockerfile`. `tests/typescript_client` covers the `typescript-client` target; it needs node and runs in `typescript-client.Dockerfile`:
+
+```
+make install-typescript-client
+make test-typescript-client
+```
+
 Merges to `main` publish a dev version to PyPI. To release, bump `version` in `pyproject.toml` in a PR, then run the Release workflow on `main` (Actions → Release → Run workflow). It tags `vX.Y.Z` and the Publish workflow publishes it. Only the release workflow can push version tags.
 
 # Things that need work
 
 ## Typing of params and fields in general
 
-Enum and OneOf not supported yet
+OneOf not supported yet
 
 I think we need to create an object for Type. what would it look like?
 

{geniespec-0.1.1.dev5 → geniespec-0.1.1.dev7}/README.md

@@ -8,11 +8,34 @@ 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 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`.
+
 # Development
 
 ```
@@ -20,13 +43,20 @@ make install
 make lint-check type-check test
 ```
 
+`tests/python_server` covers the core and the `python-server` target (the core tests generate through it) and runs in `Dockerfile`. `tests/typescript_client` covers the `typescript-client` target; it needs node and runs in `typescript-client.Dockerfile`:
+
+```
+make install-typescript-client
+make test-typescript-client
+```
+
 Merges to `main` publish a dev version to PyPI. To release, bump `version` in `pyproject.toml` in a PR, then run the Release workflow on `main` (Actions → Release → Run workflow). It tags `vX.Y.Z` and the Publish workflow publishes it. Only the release workflow can push version tags.
 
 # Things that need work
 
 ## Typing of params and fields in general
 
-Enum and OneOf not supported yet
+OneOf not supported yet
 
 I think we need to create an object for Type. what would it look like?
 

{geniespec-0.1.1.dev5 → geniespec-0.1.1.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "geniespec"
-version = "0.1.1.dev5"
+version = "0.1.1.dev7"
 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.dev5 → geniespec-0.1.1.dev7}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "geniespec"
-version = "0.1.1.dev5"
+version = "0.1.1.dev7"
 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.dev5 → geniespec-0.1.1.dev7}/src/geniespec/api_schema.yaml

@@ -32,6 +32,10 @@ properties:
     type: array
     items:
       $ref: '#/definitions/Exception'
+  enums:
+    type: array
+    items:
+      $ref: '#/definitions/Enum'
   imports:
     type: array
     items:
@@ -42,6 +46,25 @@ 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'
   Attribute:
     type: object
     additionalProperties: false
@@ -93,6 +116,8 @@ definitions:
         items:
           type: string
           pattern: '^[A-Z][A-Za-z-\[\]_, ]*$'
+      enumValues:
+        $ref: '#/definitions/EnumValues'
   Resource:
     type: object
     additionalProperties: false
@@ -221,6 +246,8 @@ definitions:
         items:
           type: string
           pattern: '^[A-Z][A-Za-z-\[\]_, ]*$'
+      enumValues:
+        $ref: '#/definitions/EnumValues'
       isRequired:
         type: boolean
       defaultValue:
@@ -271,6 +298,8 @@ definitions:
         items:
           type: string
           pattern: '^[A-Z][A-Za-z-\[\]_, ]*$'
+      enumValues:
+        $ref: '#/definitions/EnumValues'
       isNullable:
         type: boolean
       isList:

{geniespec-0.1.1.dev5 → geniespec-0.1.1.dev7}/src/geniespec/genie.py

@@ -24,11 +24,13 @@ 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 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
@@ -44,10 +46,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 +110,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 +130,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 +184,7 @@ class Renderer:
                 listValueTypes=requestField.listValueTypes,
                 mappingKeyType=requestField.mappingKeyType,
                 mappingValueTypes=requestField.mappingValueTypes,
+                enumValues=requestField.enumValues,
             ),
             defaultValue=requestField.defaultValue,
             maxValue=requestField.maxValue,
@@ -177,7 +194,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 +205,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 +220,7 @@ class Renderer:
                 listValueTypes=attribute.listValueTypes,
                 mappingKeyType=attribute.mappingKeyType,
                 mappingValueTypes=attribute.mappingValueTypes,
+                enumValues=attribute.enumValues,
             ),
             defaultValue=attribute.defaultValue,
             isUnique=attribute.isUnique,
@@ -212,11 +231,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 +253,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 +265,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 +275,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,13 +354,36 @@ 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
 
     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]
+        knownTypeNames = {**dict.fromkeys(fullResourceNames, RenderableRawTypes.CLASS), **dict.fromkeys(enumNames, RenderableRawTypes.ENUM)}
+        resourceErrors = [f'Duplicate type name: {name}' for name, count in collections.Counter(fullResourceNames + enumNames).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))
         for resource, fullName in zip(api.resources, fullResourceNames, strict=True):
             ancestorNames: list[str] = []
@@ -389,6 +438,7 @@ 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],
         )
         renderableResources: list[RenderableResource] = [self._resource_to_renderable_resource(resource=resource, knownTypeNames=knownTypeNames) for resource in api.resources]
         uncoveredTransitions: list[str] = []
@@ -466,6 +516,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.dev5 → geniespec-0.1.1.dev7}/src/geniespec/languages.py

@@ -9,10 +9,12 @@ 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 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
@@ -72,7 +74,10 @@ class BaseLanguageDefinition:
     def string_type(self, isNullable: bool) -> str:
         raise NotImplementedError
 
-    def enum_type(self, isNullable: bool, values: list[str]) -> str:
+    def enum_type(self, isNullable: bool, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool) -> str:
+        raise NotImplementedError
+
+    def file_type(self, isNullable: bool) -> str:
         raise NotImplementedError
 
     def package_name(self, api: RenderableApi) -> str:
@@ -118,14 +123,10 @@ 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)
@@ -171,6 +172,17 @@ 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}'
+
+    @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)
 
@@ -334,9 +346,19 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     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 +415,16 @@ 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 any(self.is_inline_enum(renderableType=attribute.fieldType) for resource in api.resources for attribute in resource.attributes)
+
+    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 +548,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 +611,11 @@ 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) or (valueType.rawType == RenderableRawTypes.ENUM and valueType.className is not None) for valueType in valueTypes)
+
+    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 +629,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)
@@ -609,6 +670,8 @@ 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:

{geniespec-0.1.1.dev5 → geniespec-0.1.1.dev7}/src/geniespec/renderable_types.py

@@ -87,11 +87,23 @@ class RenderableString(BaseModel):
         return cls(string=string.split(separator))
 
 
+class RenderableRawTypes:
+    CLASS = 'class'
+    ENUM = 'enum'
+    FILE = 'file'
+
+
 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 MappingRenderableType(RenderableType):
@@ -225,6 +237,7 @@ class RenderableApi(BaseModel):
     resources: list[RenderableResource]
     operations: list[RenderableOperation]
     exceptions: list[RenderableException]
+    enums: list[RenderableEnum] = []
 
 
 class ProcessableResource(BaseModel):

{geniespec-0.1.1.dev5 → geniespec-0.1.1.dev7}/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.dev5 → geniespec-0.1.1.dev7}/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.dev5 → geniespec-0.1.1.dev7}/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) %}
 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):

{geniespec-0.1.1.dev5 → geniespec-0.1.1.dev7}/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.dev5 → geniespec-0.1.1.dev7}/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.dev5 → geniespec-0.1.1.dev7}/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) %}
 

{geniespec-0.1.1.dev5 → geniespec-0.1.1.dev7}/src/geniespec/types.py

@@ -35,12 +35,25 @@ 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 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 +72,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 +83,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 +154,7 @@ class KibaApi(BaseModel):
     resources: list[Resource] = []
     transitions: list[RootTransition] = []
     exceptions: list[ApiException] = []
+    enums: list[ApiEnum] = []
     defaultAuthentication: str | None = None
 
     @property