geniespec 0.1.1.dev4__tar.gz → 0.1.1.dev5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geniespec
-Version: 0.1.1.dev4
+Version: 0.1.1.dev5
 Summary: Generate API code from an api.yaml spec
 License-Expression: MIT
 Requires-Dist: jinja2>=3.1.6
@@ -17,13 +17,14 @@ Description-Content-Type: text/markdown
 Genie (`geniespec` on PyPI) generates API code from an `api.yaml` spec. Install it like any other tool and run it from your build scripts; the generated code is gitignored, not committed.
 
 ```
-geniespec build --spec api.yaml --target python-server [--output .]
-geniespec watch --spec api.yaml --target python-server [--output .] [-- <command>]
+geniespec build --spec api.yaml --target <python-server | typescript-client> [--output .]
+geniespec watch --spec api.yaml --target <python-server | typescript-client> [--output .] [-- <command>]
 ```
 
-- `build` writes the target's package into the output directory, e.g. `./<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`) for `python-server`. Only files in that package are touched: changed files are rewritten and files it no longer generates are removed.
+- `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`.
 - `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`.
-- Code run from the output directory imports the package directly, e.g. `from my_service_api.v1 import api`. Generated `python-server` code needs `kiba-core` (`core.api`, `core.util.typing_util`), `pydantic` and `starlette`.
 - The bundled templates are examples of a kibalabs-style target.
 
 # Development

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

@@ -3,13 +3,14 @@
 Genie (`geniespec` on PyPI) generates API code from an `api.yaml` spec. Install it like any other tool and run it from your build scripts; the generated code is gitignored, not committed.
 
 ```
-geniespec build --spec api.yaml --target python-server [--output .]
-geniespec watch --spec api.yaml --target python-server [--output .] [-- <command>]
+geniespec build --spec api.yaml --target <python-server | typescript-client> [--output .]
+geniespec watch --spec api.yaml --target <python-server | typescript-client> [--output .] [-- <command>]
 ```
 
-- `build` writes the target's package into the output directory, e.g. `./<service>_api/v<major>/` (`api`, `endpoints`, `resources`, `internal`, `exceptions`) for `python-server`. Only files in that package are touched: changed files are rewritten and files it no longer generates are removed.
+- `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`.
 - `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`.
-- Code run from the output directory imports the package directly, e.g. `from my_service_api.v1 import api`. Generated `python-server` code needs `kiba-core` (`core.api`, `core.util.typing_util`), `pydantic` and `starlette`.
 - The bundled templates are examples of a kibalabs-style target.
 
 # Development

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

@@ -1,6 +1,6 @@
 [project]
 name = "geniespec"
-version = "0.1.1.dev4"
+version = "0.1.1.dev5"
 description = "Generate API code from an api.yaml spec"
 readme = "README.md"
 license = "MIT"

{geniespec-0.1.1.dev4 → geniespec-0.1.1.dev5}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "geniespec"
-version = "0.1.1.dev4"
+version = "0.1.1.dev5"
 description = "Generate API code from an api.yaml spec"
 readme = "README.md"
 license = "MIT"

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

@@ -14,6 +14,7 @@ from core.exceptions import KibaException
 
 from geniespec.languages import BaseLanguageDefinition
 from geniespec.languages import PythonLanguageDefinition
+from geniespec.languages import TypeScriptLanguageDefinition
 from geniespec.renderable_types import ActionEndpointComponent
 from geniespec.renderable_types import AttributeEndpointComponent
 from geniespec.renderable_types import EndpointContainer
@@ -46,7 +47,7 @@ from geniespec.types import ResponseTypes
 
 SCHEMA_FILE_PATH = pathlib.Path(__file__).parent / 'api_schema.yaml'
 TEMPLATES_DIRECTORY_PATH = pathlib.Path(__file__).parent / 'templates'
-TARGET_LANGUAGE_CODES = {'python-server': 'python'}
+TARGET_LANGUAGE_CODES = {'python-server': 'python', 'typescript-client': 'typescript'}
 
 
 class SyntacticValidationException(BadRequestException):
@@ -72,6 +73,8 @@ class SyntacticApiValidator:
 def get_language_definition(languageCode: str) -> BaseLanguageDefinition:
     if languageCode == 'python':
         return PythonLanguageDefinition()
+    if languageCode == 'typescript':
+        return TypeScriptLanguageDefinition()
     raise KibaException(f'Unrecognized language definition code: {languageCode}')
 
 

{geniespec-0.1.1.dev4 → geniespec-0.1.1.dev5}/src/geniespec/languages.py

@@ -1,5 +1,6 @@
 import collections
 import keyword
+import re
 
 from core.exceptions import KibaException
 
@@ -9,6 +10,7 @@ from geniespec.renderable_types import MappingRenderableType
 from geniespec.renderable_types import RenderableApi
 from geniespec.renderable_types import RenderableEndpointComponent
 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 RenderableResource
@@ -26,6 +28,7 @@ from geniespec.types import Version
 class BaseLanguageDefinition:
     FILE_EXTENSIONS: list[str]
     AUTOGENERATED_NOTICE: str
+    LANGUAGE_NAME: str
 
     def boolean_type(self, isNullable: bool) -> str:
         raise NotImplementedError
@@ -75,7 +78,13 @@ class BaseLanguageDefinition:
     def package_name(self, api: RenderableApi) -> str:
         raise NotImplementedError
 
-    def validation_errors(self, api: RenderableApi) -> list[str]:
+    def operation_name(self, operation: RenderableOperation) -> str:
+        raise NotImplementedError
+
+    def path_parameter_segment(self, parameterName: str, isInteger: bool) -> str:
+        raise NotImplementedError
+
+    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]:
@@ -131,58 +140,6 @@ class BaseLanguageDefinition:
             isNullable = False
         return self.render_type(renderableType=renderableParameter.fieldType.model_copy(update={'isNullable': isNullable}), apiVersion=apiVersion)
 
-
-class PythonLanguageDefinition(BaseLanguageDefinition):
-    AUTOGENERATED_NOTICE = '# --- THIS FILE HAS BEEN AUTOGENERATED, DO NOT MODIFY MANUALLY ---'
-
-    def boolean_type(self, isNullable: bool) -> str:
-        return 'bool | None' if isNullable else 'bool'
-
-    def datetime_type(self, isNullable: bool) -> str:
-        return 'datetime.datetime | None' if isNullable else 'datetime.datetime'
-
-    def date_type(self, isNullable: bool) -> str:
-        return 'datetime.date | None' if isNullable else 'datetime.date'
-
-    def double_type(self, isNullable: bool) -> str:
-        return 'float | None' if isNullable else 'float'
-
-    def float_type(self, isNullable: bool) -> str:
-        return 'float | None' if isNullable else 'float'
-
-    def integer_type(self, isNullable: bool) -> str:
-        return 'int | None' if isNullable else 'int'
-
-    def mapping_type(self, isNullable: bool, keyType: str, valueType: str) -> str:
-        return f'collections.abc.Mapping[{keyType}, {valueType}] | None' if isNullable else f'collections.abc.Mapping[{keyType}, {valueType}]'
-
-    def json_type(self, isNullable: bool) -> str:
-        return 'pydantic.JsonValue | None' if isNullable else 'pydantic.JsonValue'
-
-    def list_type(self, isNullable: bool, listItemType: str) -> str:
-        return f'collections.abc.Sequence[{listItemType}] | None' if isNullable else f'collections.abc.Sequence[{listItemType}]'
-
-    def struct_type(self, isNullable: bool) -> str:
-        return 'typing.JsonMapping | None' if isNullable else 'JsonMapping'
-
-    def long_integer_type(self, isNullable: bool) -> str:
-        return 'int | None' if isNullable else 'int'
-
-    def object_type(self, isNullable: bool, className: RenderableString, apiVersion: Version, isLocalReference: bool) -> str:
-        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'
-
     @staticmethod
     def _normalized_name(name: RenderableString) -> RenderableString:
         if len(name.string) != 1 or name.string[0].isupper():
@@ -208,12 +165,6 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def kebab_name(cls, name: RenderableString) -> str:
         return cls._normalized_name(name=name).kebabCaseString
 
-    def package_name(self, api: RenderableApi) -> str:
-        return f'{self.snake_name(name=api.serviceName)}_api'
-
-    def internal_class_name(self, api: RenderableApi) -> str:
-        return f'{self.pascal_name(name=api.serviceName)}ApiV{api.version.major}Internal'
-
     def resource_class_name(self, resource: RenderableResource, apiVersion: Version) -> str:
         return f'{self.pascal_name(name=resource.singleName)}V{apiVersion.major}'
 
@@ -226,17 +177,6 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def parameter_type(self, renderableParameter: RenderableParameter, apiVersion: Version) -> str:
         return self.render_parameter(renderableParameter=renderableParameter, apiVersion=apiVersion)
 
-    @staticmethod
-    def route_auth(operation: RenderableOperation) -> str | None:
-        return operation.authentication if operation.authentication not in (None, 'none') else None
-
-    @classmethod
-    def requires_auth_resolver(cls, api: RenderableApi) -> bool:
-        return any(cls.route_auth(operation=operation) is not None for operation in api.operations)
-
-    def operation_name(self, operation: RenderableOperation) -> str:
-        return self.snake_name(name=self._operation_name(operation=operation))
-
     def operation_class_name(self, operation: RenderableOperation) -> str:
         return self.pascal_name(name=self._operation_name(operation=operation))
 
@@ -246,15 +186,6 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def is_undefined_parameter(self, operation: RenderableOperation, parameter: RenderableParameter) -> bool:
         return self.http_method(operation=operation) == 'PATCH' and parameter.source == FieldSources.REQUEST and not parameter.isRequired and parameter.defaultValue is None
 
-    def requires_parameter_preprocessing(self, operation: RenderableOperation, parameter: RenderableParameter) -> bool:
-        return (parameter.defaultValue is not None and not self.is_undefined_parameter(operation=operation, parameter=parameter)) or parameter.minValue is not None or parameter.maxValue is not None
-
-    def requires_undefined(self, api: RenderableApi) -> bool:
-        return any(self.is_undefined_parameter(operation=operation, parameter=parameter) for operation in api.operations for parameter in operation.parameters)
-
-    def requires_optional_field_default(self, api: RenderableApi) -> bool:
-        return any(not self.is_undefined_parameter(operation=operation, parameter=parameter) and not parameter.isRequired and not parameter.fieldType.isNullable for operation in api.operations for parameter in self.request_parameters(operation=operation))
-
     @staticmethod
     def request_parameters(operation: RenderableOperation) -> list[RenderableParameter]:
         return [parameter for parameter in operation.parameters if parameter.source == FieldSources.REQUEST]
@@ -267,52 +198,9 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def is_redirect(operation: RenderableOperation) -> bool:
         return operation.responseType == ResponseTypes.REDIRECT
 
-    def requires_streaming(self, api: RenderableApi) -> bool:
-        return any(self.is_streaming(operation=operation) for operation in api.operations)
-
-    def requires_redirect(self, api: RenderableApi) -> bool:
-        return any(self.is_redirect(operation=operation) for operation in api.operations)
-
-    def return_type(self, operation: RenderableOperation, apiVersion: Version) -> str:
-        if operation.responseType == ResponseTypes.REDIRECT:
-            return 'str'
-        if not operation.responseFields:
-            return 'None'
-        fieldType = self.type(renderableType=operation.responseFields[0].fieldType, apiVersion=apiVersion)
-        return f'collections.abc.AsyncIterator[{fieldType}]' if operation.responseType == ResponseTypes.STREAM else fieldType
-
-    def parameter_value(self, operation: RenderableOperation, parameter: RenderableParameter) -> str:
-        if parameter.source == FieldSources.QUERY_PARAMETERS:
-            return 'dict(request.query_params)'
-        parameterName = self.identifier(name=parameter.name)
-        return parameterName if self.requires_parameter_preprocessing(operation=operation, parameter=parameter) else f'request.data.{parameterName}'
-
-    @staticmethod
-    def _contains_json(renderableType: RenderableType) -> bool:
-        if isinstance(renderableType, MappingRenderableType):
-            return PythonLanguageDefinition._contains_json(renderableType=renderableType.keyType) or PythonLanguageDefinition._contains_json(renderableType=renderableType.valueType)
-        return renderableType.rawType == PrimitiveTypes.JSON
-
-    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 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)
-
-    def exceptions_require_json(self, api: RenderableApi) -> bool:
-        return any(self._contains_json(renderableType=field.fieldType) for exception in api.exceptions for field in exception.fields)
-
     def endpoint(self, operation: RenderableOperation) -> str:
         return '/' + '/'.join([segment for component in operation.endpoint.components for segment in self._endpoint_segments(component=component)])
 
-    def route_ordered_operations(self, api: RenderableApi) -> list[RenderableOperation]:
-        return sorted(api.operations, key=lambda operation: tuple(segment.startswith('{') for segment in self.endpoint(operation=operation).split('/')))
-
-    @staticmethod
-    def literal(value: str | float | bool) -> str:
-        return repr(value)
-
     def _endpoint_segments(self, component: RenderableEndpointComponent) -> list[str]:
         if isinstance(component, AttributeEndpointComponent):
             return [self.kebab_name(name=component.attribute.name)] if component.attribute is not None else ['attributes']
@@ -326,13 +214,9 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
                 return output
             if component.attribute.isUnique and not component.attribute.isPrimary:
                 output.append(self.kebab_name(name=component.attribute.name))
-            parameterName = self.identifier(name=component.attribute.name)
-            if component.attribute.fieldType.rawType in (PrimitiveTypes.INTEGER, PrimitiveTypes.LONG_INTEGER):
-                output.append(f'{{{parameterName}:int}}')
-            elif component.attribute.fieldType.rawType == PrimitiveTypes.STRING:
-                output.append(f'{{{parameterName}:str}}')
-            else:
+            if component.attribute.fieldType.rawType not in (PrimitiveTypes.INTEGER, PrimitiveTypes.LONG_INTEGER, PrimitiveTypes.STRING):
                 raise KibaException(message=f'ResourceEndpointComponent created with an invalid attribute type of {component.attribute.fieldType}. Valid types are: integer, long integer and string.')
+            output.append(self.path_parameter_segment(parameterName=self.identifier(name=component.attribute.name), isInteger=component.attribute.fieldType.rawType != PrimitiveTypes.STRING))
             return output
         raise KibaException(message=f'Unsupported endpoint component: {type(component)}')
 
@@ -398,5 +282,358 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
         namesWithContext += [(self.identifier(name=field.name), f'response field of {route}') for operation, route in zip(api.operations, routes, strict=True) for field in operation.responseFields or []]
         namesWithContext += [(self.identifier(name=attribute.name), f'attribute of {resource.singleName.pascalCaseString}') for resource in api.resources for attribute in [*resource.attributes, *resource.independentAttributes]]
         namesWithContext += [(self.identifier(name=field.name), f'field of {exception.name.pascalCaseString}') for exception in api.exceptions for field in exception.fields]
-        errors += [f'"{name}" is not a valid Python name ({context})' for name, context in namesWithContext if not name.isidentifier() or keyword.iskeyword(name)]
+        errors += [f'"{name}" is not a valid {self.LANGUAGE_NAME} name ({context})' for name, context in namesWithContext if not self.is_valid_name(name=name)]
         return errors
+
+
+class PythonLanguageDefinition(BaseLanguageDefinition):
+    AUTOGENERATED_NOTICE = '# --- THIS FILE HAS BEEN AUTOGENERATED, DO NOT MODIFY MANUALLY ---'
+    LANGUAGE_NAME = 'Python'
+
+    def boolean_type(self, isNullable: bool) -> str:
+        return 'bool | None' if isNullable else 'bool'
+
+    def datetime_type(self, isNullable: bool) -> str:
+        return 'datetime.datetime | None' if isNullable else 'datetime.datetime'
+
+    def date_type(self, isNullable: bool) -> str:
+        return 'datetime.date | None' if isNullable else 'datetime.date'
+
+    def double_type(self, isNullable: bool) -> str:
+        return 'float | None' if isNullable else 'float'
+
+    def float_type(self, isNullable: bool) -> str:
+        return 'float | None' if isNullable else 'float'
+
+    def integer_type(self, isNullable: bool) -> str:
+        return 'int | None' if isNullable else 'int'
+
+    def mapping_type(self, isNullable: bool, keyType: str, valueType: str) -> str:
+        return f'collections.abc.Mapping[{keyType}, {valueType}] | None' if isNullable else f'collections.abc.Mapping[{keyType}, {valueType}]'
+
+    def json_type(self, isNullable: bool) -> str:
+        return 'pydantic.JsonValue | None' if isNullable else 'pydantic.JsonValue'
+
+    def list_type(self, isNullable: bool, listItemType: str) -> str:
+        return f'collections.abc.Sequence[{listItemType}] | None' if isNullable else f'collections.abc.Sequence[{listItemType}]'
+
+    def struct_type(self, isNullable: bool) -> str:
+        return 'typing.JsonMapping | None' if isNullable else 'JsonMapping'
+
+    def long_integer_type(self, isNullable: bool) -> str:
+        return 'int | None' if isNullable else 'int'
+
+    def object_type(self, isNullable: bool, className: RenderableString, apiVersion: Version, isLocalReference: bool) -> str:
+        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 package_name(self, api: RenderableApi) -> str:
+        return f'{self.snake_name(name=api.serviceName)}_api'
+
+    def internal_class_name(self, api: RenderableApi) -> str:
+        return f'{self.pascal_name(name=api.serviceName)}ApiV{api.version.major}Internal'
+
+    @staticmethod
+    def route_auth(operation: RenderableOperation) -> str | None:
+        return operation.authentication if operation.authentication not in (None, 'none') else None
+
+    @classmethod
+    def requires_auth_resolver(cls, api: RenderableApi) -> bool:
+        return any(cls.route_auth(operation=operation) is not None for operation in api.operations)
+
+    def operation_name(self, operation: RenderableOperation) -> str:
+        return self.snake_name(name=self._operation_name(operation=operation))
+
+    def requires_parameter_preprocessing(self, operation: RenderableOperation, parameter: RenderableParameter) -> bool:
+        return (parameter.defaultValue is not None and not self.is_undefined_parameter(operation=operation, parameter=parameter)) or parameter.minValue is not None or parameter.maxValue is not None
+
+    def requires_undefined(self, api: RenderableApi) -> bool:
+        return any(self.is_undefined_parameter(operation=operation, parameter=parameter) for operation in api.operations for parameter in operation.parameters)
+
+    def requires_optional_field_default(self, api: RenderableApi) -> bool:
+        return any(not self.is_undefined_parameter(operation=operation, parameter=parameter) and not parameter.isRequired and not parameter.fieldType.isNullable for operation in api.operations for parameter in self.request_parameters(operation=operation))
+
+    def requires_streaming(self, api: RenderableApi) -> bool:
+        return any(self.is_streaming(operation=operation) for operation in api.operations)
+
+    def requires_redirect(self, api: RenderableApi) -> bool:
+        return any(self.is_redirect(operation=operation) for operation in api.operations)
+
+    def return_type(self, operation: RenderableOperation, apiVersion: Version) -> str:
+        if operation.responseType == ResponseTypes.REDIRECT:
+            return 'str'
+        if not operation.responseFields:
+            return 'None'
+        fieldType = self.type(renderableType=operation.responseFields[0].fieldType, apiVersion=apiVersion)
+        return f'collections.abc.AsyncIterator[{fieldType}]' if operation.responseType == ResponseTypes.STREAM else fieldType
+
+    def parameter_value(self, operation: RenderableOperation, parameter: RenderableParameter) -> str:
+        if parameter.source == FieldSources.QUERY_PARAMETERS:
+            return 'dict(request.query_params)'
+        parameterName = self.identifier(name=parameter.name)
+        return parameterName if self.requires_parameter_preprocessing(operation=operation, parameter=parameter) else f'request.data.{parameterName}'
+
+    @staticmethod
+    def _contains_json(renderableType: RenderableType) -> bool:
+        if isinstance(renderableType, MappingRenderableType):
+            return PythonLanguageDefinition._contains_json(renderableType=renderableType.keyType) or PythonLanguageDefinition._contains_json(renderableType=renderableType.valueType)
+        return renderableType.rawType == PrimitiveTypes.JSON
+
+    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 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)
+
+    def exceptions_require_json(self, api: RenderableApi) -> bool:
+        return any(self._contains_json(renderableType=field.fieldType) for exception in api.exceptions for field in exception.fields)
+
+    def route_ordered_operations(self, api: RenderableApi) -> list[RenderableOperation]:
+        return sorted(api.operations, key=lambda operation: tuple(segment.startswith('{') for segment in self.endpoint(operation=operation).split('/')))
+
+    @staticmethod
+    def literal(value: str | float | bool) -> str:
+        return repr(value)
+
+    def path_parameter_segment(self, parameterName: str, isInteger: bool) -> str:
+        return f'{{{parameterName}:int}}' if isInteger else f'{{{parameterName}:str}}'
+
+    def is_valid_name(self, name: str) -> bool:
+        return name.isidentifier() and not keyword.iskeyword(name)
+
+
+class TypeScriptLanguageDefinition(BaseLanguageDefinition):
+    AUTOGENERATED_NOTICE = '// --- THIS FILE HAS BEEN AUTOGENERATED, DO NOT MODIFY MANUALLY ---'
+    LANGUAGE_NAME = 'TypeScript'
+    # NOTE(krishan711): names are used as constructor and method parameters, so they can't be words reserved in strict mode modules
+    RESERVED_WORDS = frozenset(
+        {
+            'arguments',
+            'await',
+            'break',
+            'case',
+            'catch',
+            'class',
+            'const',
+            'continue',
+            'debugger',
+            'default',
+            'delete',
+            'do',
+            'else',
+            'enum',
+            'eval',
+            'export',
+            'extends',
+            'false',
+            'finally',
+            'for',
+            'function',
+            'if',
+            'implements',
+            'import',
+            'in',
+            'instanceof',
+            'interface',
+            'let',
+            'new',
+            'null',
+            'package',
+            'private',
+            'protected',
+            'public',
+            'return',
+            'static',
+            'super',
+            'switch',
+            'this',
+            'throw',
+            'true',
+            'try',
+            'typeof',
+            'var',
+            'void',
+            'while',
+            'with',
+            'yield',
+        }
+    )
+    QUERY_METHODS = frozenset({'GET', 'DELETE'})
+
+    @staticmethod
+    def _nullable(typeName: str, isNullable: bool) -> str:
+        return f'{typeName} | null' if isNullable else typeName
+
+    def boolean_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='boolean', isNullable=isNullable)
+
+    def datetime_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='Date', isNullable=isNullable)
+
+    def date_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='Date', isNullable=isNullable)
+
+    def double_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='number', isNullable=isNullable)
+
+    def float_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='number', isNullable=isNullable)
+
+    def integer_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='number', isNullable=isNullable)
+
+    def long_integer_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='number', isNullable=isNullable)
+
+    def mapping_type(self, isNullable: bool, keyType: str, valueType: str) -> str:  # noqa: ARG002
+        # NOTE(krishan711): json object keys are always strings
+        return self._nullable(typeName=f'Record<string, {valueType}>', isNullable=isNullable)
+
+    def render_type(self, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool = False) -> str:
+        if renderableType.rawType == PrimitiveTypes.JSON and not renderableType.isList:
+            return self._nullable(typeName='JsonValue' if isLocalReference else 'Resources.JsonValue', isNullable=renderableType.isNullable)
+        return super().render_type(renderableType=renderableType, apiVersion=apiVersion, isLocalReference=isLocalReference)
+
+    def list_type(self, isNullable: bool, listItemType: str) -> str:
+        return self._nullable(typeName=f'{listItemType}[]', isNullable=isNullable)
+
+    def object_type(self, isNullable: bool, className: RenderableString, apiVersion: Version, isLocalReference: bool) -> str:
+        typeName = f'{className.pascalCaseString}V{apiVersion.major}'
+        return self._nullable(typeName=typeName if isLocalReference else f'Resources.{typeName}', isNullable=isNullable)
+
+    def string_type(self, isNullable: bool) -> str:
+        return self._nullable(typeName='string', isNullable=isNullable)
+
+    def package_name(self, api: RenderableApi) -> str:
+        return f'{self.kebab_name(name=api.serviceName)}-api'
+
+    def client_class_name(self, api: RenderableApi) -> str:
+        return f'{self.pascal_name(name=api.serviceName)}ApiV{api.version.major}Client'
+
+    def operation_name(self, operation: RenderableOperation) -> str:
+        return self._operation_name(operation=operation).camelCaseString
+
+    def path_parameter_segment(self, parameterName: str, isInteger: bool) -> str:
+        return f'${{{parameterName}}}' if isInteger else f'${{encodeURIComponent({parameterName})}}'
+
+    def is_valid_name(self, name: str) -> bool:
+        return re.fullmatch(r'[A-Za-z_$][A-Za-z0-9_$]*', name) is not None and name not in self.RESERVED_WORDS
+
+    def client_operations(self, api: RenderableApi) -> list[RenderableOperation]:
+        # NOTE(krishan711): redirects are opened by browsers and query-parameters fields receive third-party callbacks, so neither is called from a client
+        return [operation for operation in api.operations if not self.is_redirect(operation=operation) and all(parameter.source == FieldSources.REQUEST for parameter in operation.parameters)]
+
+    def client_path(self, operation: RenderableOperation) -> str:
+        return self.endpoint(operation=operation).removeprefix('/')
+
+    def body_parameters(self, operation: RenderableOperation) -> list[RenderableParameter]:
+        urlParameterNames = {self.identifier(name=parameter.name) for parameter in operation.urlParameters}
+        return [parameter for parameter in self.request_parameters(operation=operation) if self.identifier(name=parameter.name) not in urlParameterNames]
+
+    def is_query_operation(self, operation: RenderableOperation) -> bool:
+        return self.http_method(operation=operation) in self.QUERY_METHODS
+
+    def are_parameters_optional(self, operation: RenderableOperation) -> bool:
+        return all(not self.is_parameter_required(operation=operation, parameter=parameter) for parameter in self.body_parameters(operation=operation))
+
+    def is_parameter_required(self, operation: RenderableOperation, parameter: RenderableParameter) -> bool:
+        return parameter.isRequired and parameter.defaultValue is None and not (self.is_query_operation(operation=operation) and parameter.fieldType.isNullable)
+
+    def parameter_field_type(self, operation: RenderableOperation, parameter: RenderableParameter) -> RenderableType:
+        # NOTE(krishan711): null can't be sent in a query string, leaving the parameter out has the same meaning
+        isNullable = parameter.fieldType.isNullable and parameter.defaultValue is None and not self.is_query_operation(operation=operation)
+        return parameter.fieldType.model_copy(update={'isNullable': isNullable})
+
+    def response_field(self, operation: RenderableOperation) -> RenderableField | None:
+        return operation.responseFields[0] if operation.responseFields else None
+
+    def stream_callback_name(self, operation: RenderableOperation) -> str:
+        responseField = self.response_field(operation=operation)
+        if responseField is None:
+            raise KibaException(message=f'Stream operation {self.endpoint(operation=operation)} has no response field')
+        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))
+
+    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))
+
+    def resource_field_types(self, api: RenderableApi) -> list[RenderableType]:
+        return [attribute.fieldType for resource in api.resources for attribute in resource.attributes]
+
+    def response_field_types(self, api: RenderableApi) -> list[RenderableType]:
+        return [field.fieldType for operation in self.client_operations(api=api) for field in operation.responseFields or []]
+
+    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 _contains_raw_type(self, renderableType: RenderableType, rawType: str) -> bool:
+        if isinstance(renderableType, MappingRenderableType):
+            return self._contains_raw_type(renderableType=renderableType.valueType, rawType=rawType)
+        return renderableType.rawType == rawType
+
+    def from_object(self, renderableType: RenderableType, value: str, apiVersion: Version, isLocalReference: bool = False) -> str:
+        if renderableType.isNullable:
+            converted = self.from_object(renderableType=renderableType.model_copy(update={'isNullable': False}), value=value, apiVersion=apiVersion, isLocalReference=isLocalReference)
+            return f'{value} != null ? {converted} : null'
+        if renderableType.isList:
+            itemType = renderableType.model_copy(update={'isList': False})
+            itemTypeName = self.type(renderableType=itemType, apiVersion=apiVersion, isLocalReference=isLocalReference)
+            return f'({value} as unknown[]).map((entry: unknown): {itemTypeName} => {self.from_object(renderableType=itemType, value="entry", apiVersion=apiVersion, isLocalReference=isLocalReference)})'
+        if isinstance(renderableType, MappingRenderableType):
+            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 == '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:
+            return f'String({value})'
+        if renderableType.rawType in (PrimitiveTypes.INTEGER, PrimitiveTypes.LONG_INTEGER, PrimitiveTypes.FLOAT, PrimitiveTypes.DOUBLE):
+            return f'Number({value})'
+        if renderableType.rawType == PrimitiveTypes.BOOLEAN:
+            return f'Boolean({value})'
+        if renderableType.rawType in (PrimitiveTypes.DATE, PrimitiveTypes.DATETIME):
+            return f'dateFromString(String({value}))'
+        if renderableType.rawType == PrimitiveTypes.JSON:
+            return f'{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)
+
+    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):
+            return value
+        if renderableType.isNullable or isOptional:
+            converted = self.to_object(renderableType=renderableType.model_copy(update={'isNullable': False}), value=value, apiVersion=apiVersion, isLocalReference=isLocalReference)
+            return f'{value} == null ? {value} : {converted}'
+        if renderableType.isList:
+            itemType = renderableType.model_copy(update={'isList': False})
+            itemTypeName = self.type(renderableType=itemType, apiVersion=apiVersion, isLocalReference=isLocalReference)
+            return f'{value}.map((entry: {itemTypeName}): unknown => {self.to_object(renderableType=itemType, value="entry", apiVersion=apiVersion, isLocalReference=isLocalReference)})'
+        if isinstance(renderableType, MappingRenderableType):
+            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':
+            return f'{value}.toObject()'
+        if renderableType.rawType == PrimitiveTypes.DATETIME:
+            return f'dateToString({value})'
+        if renderableType.rawType == PrimitiveTypes.DATE:
+            return f"dateToString({value}, 'yyyy-MM-dd')"
+        raise KibaException(f'Failed to render conversion to object for: {renderableType}')

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

@@ -0,0 +1,41 @@
+{{ autogenerated_notice }}
+import { RestMethod, ServiceClient } from '@kibalabs/core';
+
+import * as Endpoints from './endpoints';
+{% if target.references_resources(renderableTypes=target.response_field_types(api=api)) %}
+import * as Resources from './resources';
+{% endif %}
+
+export class {{ target.client_class_name(api=api) }} extends ServiceClient {
+{% for operation in target.client_operations(api=api) %}
+{% set className = target.operation_class_name(operation=operation) %}
+{% set bodyParameters = target.body_parameters(operation=operation) %}
+{% set responseField = target.response_field(operation=operation) %}
+{% set arguments = [] %}
+{% for parameter in operation.urlParameters %}{% set _ = arguments.append(target.identifier(name=parameter.name) ~ ': ' ~ target.type(renderableType=parameter.fieldType, apiVersion=api.version)) %}{% endfor %}
+{% if bodyParameters %}{% set _ = arguments.append('params: Endpoints.' ~ className ~ 'Params' ~ (' = {}' if target.are_parameters_optional(operation=operation) and not target.is_streaming(operation=operation) else '')) %}{% endif %}
+{% if target.is_streaming(operation=operation) %}{% set _ = arguments.append(target.stream_callback_name(operation=operation) ~ ': (' ~ target.identifier(name=responseField.name) ~ ': ' ~ target.type(renderableType=responseField.fieldType, apiVersion=api.version) ~ ') => void') %}{% endif %}
+{% set path = target.client_path(operation=operation) %}
+{% set pathLiteral = ('`' ~ path ~ '`') if operation.urlParameters else ("'" ~ path ~ "'") %}
+{% set request = ('new Endpoints.' ~ className ~ 'Request(params)') if bodyParameters else 'undefined' %}
+{% if not loop.first %}
+
+{% endif %}
+{% if 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) }});
+    });
+  };
+{% elif responseField %}
+  public {{ target.operation_name(operation=operation) }} = async ({{ arguments | join(', ') }}): Promise<{{ target.type(renderableType=responseField.fieldType, apiVersion=api.version) }}> => {
+    const response = await this.makeRequest(RestMethod.{{ target.http_method(operation=operation) }}, {{ pathLiteral }}, {{ request }}, Endpoints.{{ className }}Response);
+    return response.{{ target.identifier(name=responseField.name) }};
+  };
+{% else %}
+  public {{ target.operation_name(operation=operation) }} = async ({{ arguments | join(', ') }}): Promise<void> => {
+    await this.makeRequest(RestMethod.{{ target.http_method(operation=operation) }}, {{ pathLiteral }}, {{ request }});
+  };
+{% endif %}
+{% endfor %}
+}

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

@@ -0,0 +1,59 @@
+{{ autogenerated_notice }}
+{% set responseTypes = target.response_field_types(api=api) %}
+{% set bodyTypes = target.body_parameter_types(api=api) %}
+{% set coreImports = [] %}
+{% 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 responseTypes %}{% set _ = coreImports.append('ResponseData') %}{% endif %}
+import { {{ coreImports | join(', ') }} } from '@kibalabs/core';
+{% if target.references_resources(renderableTypes=responseTypes + bodyTypes) %}
+
+import * as Resources from './resources';
+{% endif %}
+{% for operation in target.client_operations(api=api) %}
+{% set className = target.operation_class_name(operation=operation) %}
+{% set bodyParameters = target.body_parameters(operation=operation) %}
+{% set responseField = target.response_field(operation=operation) %}
+{% if bodyParameters %}
+
+export interface {{ className }}Params {
+{% for parameter in bodyParameters %}
+  {{ target.identifier(name=parameter.name) }}{% if not target.is_parameter_required(operation=operation, parameter=parameter) %}?{% endif %}: {{ target.type(renderableType=target.parameter_field_type(operation=operation, parameter=parameter), apiVersion=api.version) }};
+{% endfor %}
+}
+
+export class {{ className }}Request extends RequestData {
+  public constructor(
+    readonly params: {{ className }}Params,
+  ) {
+    super();
+  }
+
+  public toObject = (): RawObject => {
+    return {
+{% for parameter in bodyParameters %}
+      {{ target.identifier(name=parameter.name) }}: {{ target.to_object(renderableType=target.parameter_field_type(operation=operation, parameter=parameter), value='this.params.' ~ target.identifier(name=parameter.name), apiVersion=api.version, isOptional=not target.is_parameter_required(operation=operation, parameter=parameter)) }},
+{% endfor %}
+    };
+  };
+}
+{% endif %}
+{% if responseField %}
+
+export class {{ className }}Response extends ResponseData {
+  public constructor(
+    readonly {{ target.identifier(name=responseField.name) }}: {{ target.type(renderableType=responseField.fieldType, apiVersion=api.version) }},
+  ) {
+    super();
+  }
+
+  public static fromObject = (obj: RawObject): {{ className }}Response => {
+    return new {{ className }}Response(
+      {{ target.from_object(renderableType=responseField.fieldType, value='obj.' ~ target.identifier(name=responseField.name), apiVersion=api.version) }},
+    );
+  };
+}
+{% endif %}
+{% endfor %}

geniespec-0.1.1.dev5/src/geniespec/templates/typescript-client/{service}/v{version}/index.ts.j2

@@ -0,0 +1,4 @@
+{{ autogenerated_notice }}
+export * from './client';
+export * from './endpoints';
+export * from './resources';

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

@@ -0,0 +1,45 @@
+{{ autogenerated_notice }}
+{% if target.requires_date_parsing(renderableTypes=target.resource_field_types(api=api)) %}
+import { dateFromString, dateToString, RawObject } from '@kibalabs/core';
+{% else %}
+import { RawObject } from '@kibalabs/core';
+{% endif %}
+
+export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
+{% for resource in api.resources %}
+{% set className = target.resource_class_name(resource=resource, apiVersion=api.version) %}
+
+export class {{ className }} {
+{% if resource.attributes %}
+  public constructor(
+{% for attribute in resource.attributes %}
+    readonly {{ target.identifier(name=attribute.name) }}: {{ target.type(renderableType=attribute.fieldType, apiVersion=api.version, isLocalReference=True) }},
+{% endfor %}
+  ) { }
+
+  public static fromObject = (obj: RawObject): {{ className }} => {
+    return new {{ className }}(
+{% for attribute in resource.attributes %}
+      {{ target.from_object(renderableType=attribute.fieldType, value='obj.' ~ target.identifier(name=attribute.name), apiVersion=api.version, isLocalReference=True) }},
+{% endfor %}
+    );
+  };
+
+  public toObject = (): RawObject => {
+    return {
+{% for attribute in resource.attributes %}
+      {{ target.identifier(name=attribute.name) }}: {{ target.to_object(renderableType=attribute.fieldType, value='this.' ~ target.identifier(name=attribute.name), apiVersion=api.version, isLocalReference=True) }},
+{% endfor %}
+    };
+  };
+{% else %}
+  public static fromObject = (): {{ className }} => {
+    return new {{ className }}();
+  };
+
+  public toObject = (): RawObject => {
+    return {};
+  };
+{% endif %}
+}
+{% endfor %}