geniespec 0.1.1.dev2__py3-none-any.whl

geniespec/genie.py

@@ -0,0 +1,505 @@
+from __future__ import annotations
+
+import collections
+import os
+import pathlib
+import typing
+
+import jinja2
+import jsonschema  # type: ignore[import-untyped]
+import yaml  # type: ignore[import-untyped]
+from core import logging
+from core.exceptions import BadRequestException
+from core.exceptions import KibaException
+
+from geniespec.languages import BaseLanguageDefinition
+from geniespec.languages import PythonLanguageDefinition
+from geniespec.renderable_types import ActionEndpointComponent
+from geniespec.renderable_types import AttributeEndpointComponent
+from geniespec.renderable_types import EndpointContainer
+from geniespec.renderable_types import ExceptionRenderableField
+from geniespec.renderable_types import MappingRenderableType
+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 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 RenderableResource
+from geniespec.renderable_types import RenderableString
+from geniespec.renderable_types import RenderableType
+from geniespec.renderable_types import ResourceEndpointComponent
+from geniespec.renderable_types import SingleResourceEndpointComponent
+from geniespec.types import Attribute
+from geniespec.types import BaseTransition
+from geniespec.types import ComplexTypes
+from geniespec.types import FieldSources
+from geniespec.types import KibaApi
+from geniespec.types import PrimitiveTypes
+from geniespec.types import RequestField
+from geniespec.types import Resource
+from geniespec.types import ResponseField
+from geniespec.types import ResponseTypes
+
+SCHEMA_FILE_PATH = pathlib.Path(__file__).parent / 'api_schema.yaml'
+TEMPLATES_DIRECTORY_PATH = pathlib.Path(__file__).parent / 'templates'
+
+
+class SyntacticValidationException(BadRequestException):
+    pass
+
+
+class SemanticValidationException(BadRequestException):
+    pass
+
+
+class SyntacticApiValidator:
+    def __init__(self) -> None:
+        with open(SCHEMA_FILE_PATH) as schemaFile:
+            self.schema: str = yaml.safe_load(schemaFile)
+
+    def validate(self, apiYaml: dict[str, object]) -> None:
+        try:
+            jsonschema.validate(instance=apiYaml, schema=self.schema)
+        except jsonschema.exceptions.ValidationError as validationError:
+            raise SyntacticValidationException(message=str(validationError))
+
+
+def get_language_definition(languageCode: str) -> BaseLanguageDefinition:
+    if languageCode == 'python':
+        return PythonLanguageDefinition()
+    raise KibaException(f'Unrecognized language definition code: {languageCode}')
+
+
+JINJA_FUNCTIONS: dict[str, typing.Callable[[str], BaseLanguageDefinition]] = {
+    'get_language_definition': get_language_definition,
+}
+
+
+class Renderer:
+    def __init__(self) -> None:
+        self.templateDirectoryPath = str(TEMPLATES_DIRECTORY_PATH / 'python')
+        self.languageDefinition = get_language_definition(languageCode='python')
+        self.jinjaEnvironment = jinja2.Environment(loader=jinja2.FileSystemLoader(self.templateDirectoryPath), autoescape=jinja2.select_autoescape(), keep_trailing_newline=True, trim_blocks=True)
+        self.jinjaEnvironment.globals['autogenerated_notice'] = self.languageDefinition.AUTOGENERATED_NOTICE
+
+    @staticmethod
+    def _add_service_name_to_path(targetPath: str, outputDirectoryPath: str, serviceName: str, apiVersion: str) -> str:
+        replacedPath = targetPath
+        if targetPath is not outputDirectoryPath:
+            target = targetPath.split(outputDirectoryPath, 1)[1].strip('/')
+            replacedPath = os.path.join(outputDirectoryPath, target.format(service=serviceName, version=apiVersion))
+        return replacedPath
+
+    @staticmethod
+    def _transition_to_renderable_method(transition: BaseTransition) -> RenderableMethod:
+        defaultMethods = {'DELETE': 'DELETE', 'UPDATE': 'PATCH', 'GET': 'GET', 'CREATE': 'POST', 'LIST': 'GET'}
+        if transition.method is not None and transition.action.upper() in defaultMethods:
+            raise SemanticValidationException(message=f'Only custom transitions can set a method: {transition.action}')
+        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:
+        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'
+        return RenderableOperation(
+            method=method,
+            endpoint=endpoint,
+            query=fields if isQuery else None,
+            body=None if isQuery else fields,
+            responseFields=[self._response_field_to_renderable_field(responseField=transition.responseField, knownTypeNames=knownTypeNames)] if transition.responseField is not None else None,
+            authentication=transition.authentication or defaultAuthentication,
+            isIndirectAction=isIndirectAction,
+            responseType=transition.responseType,
+        )
+
+    def _type_to_renderable_type(
+        self,
+        rawType: str,
+        isNullable: bool,
+        isList: bool,
+        knownTypeNames: set[str],
+        listValueTypes: list[str] | None = None,
+        mappingKeyType: str | None = None,
+        mappingValueTypes: list[str] | None = None,
+    ) -> RenderableType:
+        listValueTypes = listValueTypes or []
+        mappingValueTypes = mappingValueTypes or []
+        if rawType == ComplexTypes.MAPPING:
+            if mappingKeyType is None or len(mappingValueTypes) == 0:
+                raise KibaException(message='Mapping types require mappingKeyType and mappingValueTypes')
+            keyType = self._type_to_renderable_type(rawType=mappingKeyType, isNullable=False, isList=False, knownTypeNames=knownTypeNames)
+            nonNullValueTypes = [valueType for valueType in mappingValueTypes if valueType != '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)
+            return MappingRenderableType(isNullable=isNullable, isList=isList, keyType=keyType, valueType=valueType)
+        if rawType == '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)
+            if itemType.isList:
+                raise KibaException(message='Nested list types are not supported')
+            return RenderableType(rawType=itemType.rawType, isNullable=isNullable, isList=True, className=itemType.className)
+        if listValueTypes:
+            raise KibaException(message=f'Only List types may define listValueTypes: {rawType}')
+        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)
+        raise KibaException(message=f'Unknown type: {rawType}')
+
+    def _request_field_to_renderable_parameter(self, requestField: RequestField, knownTypeNames: set[str]) -> RenderableParameter:
+        return RenderableParameter(
+            name=RenderableString.from_kebab_case_string(string=requestField.name),
+            fieldType=self._type_to_renderable_type(
+                rawType=requestField.fieldType,
+                isNullable=not requestField.isRequired,
+                isList=False,
+                knownTypeNames=knownTypeNames,
+                listValueTypes=requestField.listValueTypes,
+                mappingKeyType=requestField.mappingKeyType,
+                mappingValueTypes=requestField.mappingValueTypes,
+            ),
+            defaultValue=requestField.defaultValue,
+            maxValue=requestField.maxValue,
+            minValue=requestField.minValue,
+            isRequired=requestField.isRequired,
+            isDeprecated=requestField.isDeprecated,
+            source=requestField.source,
+        )
+
+    def _response_field_to_renderable_field(self, responseField: ResponseField, knownTypeNames: set[str]) -> RenderableField:
+        return RenderableField(
+            name=RenderableString.from_kebab_case_string(string=responseField.name),
+            fieldType=self._type_to_renderable_type(
+                rawType=responseField.fieldType,
+                isNullable=responseField.isNullable,
+                isList=responseField.isList,
+                knownTypeNames=knownTypeNames,
+                listValueTypes=responseField.listValueTypes,
+                mappingKeyType=responseField.mappingKeyType,
+                mappingValueTypes=responseField.mappingValueTypes,
+            ),
+        )
+
+    def _attribute_to_renderable_attribute(self, attribute: Attribute, knownTypeNames: set[str], isNullable: bool | None = None) -> RenderableAttribute:
+        return RenderableAttribute(
+            name=RenderableString.from_kebab_case_string(string=attribute.name),
+            fieldType=self._type_to_renderable_type(
+                rawType=attribute.fieldType,
+                isNullable=attribute.isNullable if isNullable is None else isNullable,
+                isList=False,
+                knownTypeNames=knownTypeNames,
+                listValueTypes=attribute.listValueTypes,
+                mappingKeyType=attribute.mappingKeyType,
+                mappingValueTypes=attribute.mappingValueTypes,
+            ),
+            defaultValue=attribute.defaultValue,
+            isUnique=attribute.isUnique,
+            isPrimary=attribute.isPrimary,
+            isUpdatable=attribute.isUpdatable,
+            isAccessibleIndependently=attribute.isAccessibleIndependently,
+            isSettable=attribute.isSettable,
+            isNullable=attribute.isNullable,
+        )
+
+    def _attribute_to_renderable_parameter(self, attribute: Attribute, isRequired: bool, knownTypeNames: set[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
+            ),
+            defaultValue=attribute.defaultValue if shouldUseDefault else None,
+            isRequired=isRequired,
+            isDeprecated=attribute.isDeprecated,
+        )
+
+    @staticmethod
+    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:
+        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)),
+            collectionName=RenderableString.from_pascal_case_string(string=self._resource_full_name(resource=resource, name=resource.collectionName)),
+            parentResource=resource.parentResource,
+            attributes=[attribute for attribute in attributes if not attribute.isAccessibleIndependently],
+            independentAttributes=[attribute for attribute in attributes if attribute.isAccessibleIndependently],
+            primaryAttribute=next((attribute for attribute in attributes if attribute.isPrimary), None),
+            accessibleFrom=resource.accessibleFrom,
+        )
+
+    def _get_processable_resource(self, renderableResource: RenderableResource, allResources: list[RenderableResource], knownTypeNames: set[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)
+        if parentResource is not None:
+            parentProcessableResource = self._get_processable_resource(renderableResource=parentResource, allResources=allResources, knownTypeNames=knownTypeNames)
+            isOneToOne = renderableResource.primaryAttribute == parentResource.primaryAttribute
+            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:
+                    occursInResource = self._get_processable_resource(renderableResource=otherResource, allResources=allResources, knownTypeNames=knownTypeNames)
+                    occursInAttribute = attribute
+                    attributeOccurrences.append(ProcessableResource.IndependentAttributeOccurrence(processableResource=occursInResource, attribute=occursInAttribute))
+        return ProcessableResource(renderableResource=renderableResource, parent=parent, occursAsIndependentAttribute=attributeOccurrences)
+
+    @staticmethod
+    def _relative_name(name: RenderableString, anchor: RenderableResource | None) -> RenderableString:
+        return RenderableString(string=name.string[len(anchor.singleName.string) :]) if anchor is not None else name
+
+    def _resource_component(self, resource: RenderableResource, attribute: RenderableAttribute | None, anchor: RenderableResource | None) -> ResourceEndpointComponent:
+        return ResourceEndpointComponent(
+            resource=resource,
+            attribute=attribute,
+            relativeSingleName=self._relative_name(name=resource.singleName, anchor=anchor),
+            relativeCollectionName=self._relative_name(name=resource.collectionName, anchor=anchor),
+        )
+
+    def _get_anchored_endpoints(self, resource: RenderableResource, anchor: ProcessableResource | None) -> EndpointContainer:
+        anchorEndpoints = self._get_canonical_endpoints(processableResource=anchor).individualEndpoints if anchor is not None else [RenderableEndpoint(components=[])]
+        anchorResource = anchor.renderableResource if anchor is not None else None
+        individualEndpoints = [RenderableEndpoint(components=[*endpoint.components, self._resource_component(resource=resource, attribute=resource.primaryAttribute, anchor=anchorResource)]) for endpoint in anchorEndpoints] if resource.primaryAttribute else []
+        collectionEndpoints = [RenderableEndpoint(components=[*endpoint.components, self._resource_component(resource=resource, attribute=None, anchor=anchorResource)]) for endpoint in anchorEndpoints]
+        return EndpointContainer(individualEndpoints=individualEndpoints, collectionEndpoints=collectionEndpoints)
+
+    def _get_canonical_endpoints(self, processableResource: ProcessableResource) -> EndpointContainer:
+        resource = processableResource.renderableResource
+        parent = processableResource.parent
+        if parent is None:
+            return self._get_anchored_endpoints(resource=resource, anchor=None)
+        if parent.isOneToOne:
+            parentEndpoints = self._get_canonical_endpoints(processableResource=parent.processableResource).individualEndpoints
+            relativeSingleName = self._relative_name(name=resource.singleName, anchor=parent.processableResource.renderableResource)
+            return EndpointContainer(
+                individualEndpoints=[RenderableEndpoint(components=[*endpoint.components, SingleResourceEndpointComponent(resource=resource, relativeSingleName=relativeSingleName)]) for endpoint in parentEndpoints],
+                collectionEndpoints=[],
+            )
+        return self._get_anchored_endpoints(resource=resource, anchor=parent.processableResource)
+
+    def _get_resource_endpoints(self, processableResource: ProcessableResource) -> EndpointContainer:
+        resource = processableResource.renderableResource
+        individualEndpoints: list[RenderableEndpoint] = []
+        collectionEndpoints: list[RenderableEndpoint] = []
+        for anchorName in resource.accessibleFrom:
+            anchor = None
+            ancestor = processableResource.parent
+            while anchorName != 'root' and ancestor is not None and anchor is None:
+                if ancestor.processableResource.renderableResource.singleName.pascalCaseString == anchorName:
+                    anchor = ancestor.processableResource
+                ancestor = ancestor.processableResource.parent
+            anchoredEndpoints = self._get_anchored_endpoints(resource=resource, anchor=anchor)
+            individualEndpoints += anchoredEndpoints.individualEndpoints
+            collectionEndpoints += anchoredEndpoints.collectionEndpoints
+        canonicalEndpoints = self._get_canonical_endpoints(processableResource=processableResource)
+        individualEndpoints += canonicalEndpoints.individualEndpoints
+        collectionEndpoints += canonicalEndpoints.collectionEndpoints
+        for occurrence in processableResource.occursAsIndependentAttribute:
+            parentEndpoints = self._get_canonical_endpoints(processableResource=occurrence.processableResource).individualEndpoints
+            individualEndpoints += [RenderableEndpoint(components=[*endpoint.components, AttributeEndpointComponent(attribute=occurrence.attribute, resource=resource)]) for endpoint in parentEndpoints]
+        return EndpointContainer(individualEndpoints=individualEndpoints, collectionEndpoints=collectionEndpoints)
+
+    @staticmethod
+    def _is_string_mapping(renderableType: RenderableType) -> bool:
+        return isinstance(renderableType, MappingRenderableType) and renderableType.keyType.rawType == PrimitiveTypes.STRING and renderableType.valueType.rawType == PrimitiveTypes.STRING
+
+    def _operation_errors(self, operation: RenderableOperation) -> list[str]:
+        lastComponent = operation.endpoint.components[-1] if operation.endpoint.components else None
+        name = lastComponent.actionName.kebabCaseString if isinstance(lastComponent, ActionEndpointComponent) and lastComponent.actionName is not None else operation.method.method.upperCaseString
+        parametersBySource: dict[str, list[RenderableParameter]] = collections.defaultdict(list)
+        for parameter in operation.parameters:
+            parametersBySource[parameter.source].append(parameter)
+        errors: list[str] = []
+        errors += [f'{name}: query-parameters field {parameter.name.kebabCaseString} must be a Mapping of String to String' for parameter in parametersBySource[FieldSources.QUERY_PARAMETERS] if not self._is_string_mapping(renderableType=parameter.fieldType)]
+        if len(parametersBySource[FieldSources.QUERY_PARAMETERS]) > 1:
+            errors.append(f'{name}: only one query-parameters field is allowed')
+        if operation.responseType == ResponseTypes.STREAM and not operation.responseFields:
+            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')
+        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]
+        resourcesByName = dict(zip(fullResourceNames, api.resources, strict=False))
+        for resource, fullName in zip(api.resources, fullResourceNames, strict=True):
+            ancestorNames: list[str] = []
+            ancestor = resourcesByName.get(resource.parentResource) if resource.parentResource is not None else None
+            while ancestor is not None:
+                ancestorName = self._resource_full_name(resource=ancestor, name=ancestor.singleName)
+                ancestorNames.append(ancestorName)
+                ancestor = resourcesByName.get(ancestor.parentResource) if ancestor.parentResource is not None else None
+            for anchorName in resource.accessibleFrom:
+                if anchorName == resource.parentResource or (anchorName == 'root' and resource.parentResource is None):
+                    resourceErrors.append(f'{fullName} is already accessible from {anchorName}')
+                elif anchorName != 'root' and anchorName not in ancestorNames:
+                    resourceErrors.append(f'{fullName} can only be accessible from root or an ancestor, not {anchorName}')
+            parentPrimaryAttribute = resourcesByName[resource.parentResource].primaryAttribute if resource.parentResource in resourcesByName else None
+            isOneToOne = parentPrimaryAttribute is not None and resource.primaryAttribute is not None and resource.primaryAttribute.name == parentPrimaryAttribute.name
+            expectedPrimaryName = f'{RenderableString.from_pascal_case_string(string=fullName).kebabCaseString}-id'
+            if resource.transitions and resource.primaryAttribute is not None and not isOneToOne and resource.primaryAttribute.name != expectedPrimaryName:
+                resourceErrors.append(f'Primary attribute of {fullName} must be {expectedPrimaryName}, found {resource.primaryAttribute.name}')
+        if resourceErrors:
+            raise SemanticValidationException(message='\n'.join(resourceErrors))
+        renderableOperations = [
+            self._action_operation(
+                transition=transition,
+                endpoint=RenderableEndpoint(components=[ActionEndpointComponent(actionName=RenderableString.from_separated_string(string=transition.action, separator='-'))]),
+                knownTypeNames=knownTypeNames,
+                defaultAuthentication=api.defaultAuthentication,
+            )
+            for transition in api.transitions
+        ]
+        renderableExceptions = [
+            RenderableException(
+                name=RenderableString.from_pascal_case_string(string=exception.name),
+                message=exception.message,
+                statusCode=exception.statusCode,
+                fields=[
+                    ExceptionRenderableField(
+                        name=RenderableString.from_snake_case_string(string=field.name),
+                        fieldType=self._type_to_renderable_type(rawType=field.fieldType, isNullable=field.isNullable, isList=False, knownTypeNames=knownTypeNames, listValueTypes=field.listValueTypes),
+                        defaultValue=field.defaultValue,
+                        isRequired=field.isRequired,
+                    )
+                    for field in exception.fields
+                ],
+            )
+            for exception in api.exceptions
+        ]
+        renderableApi = RenderableApi(
+            version=api.versionObject,
+            serviceName=RenderableString.from_kebab_case_string(string=api.serviceName),
+            pythonClientPackageName=api.pythonClientPackageName,
+            typescriptClientPackageName=api.typescriptClientPackageName,
+            resources=[],
+            operations=renderableOperations,
+            exceptions=renderableExceptions,
+        )
+        renderableResources: list[RenderableResource] = [self._resource_to_renderable_resource(resource=resource, knownTypeNames=knownTypeNames) for resource in api.resources]
+        uncoveredTransitions: list[str] = []
+        for resource, renderableResource in zip(api.resources, renderableResources, strict=True):
+            processableResource = self._get_processable_resource(renderableResource=renderableResource, allResources=renderableResources, knownTypeNames=knownTypeNames)
+            endpoints = self._get_resource_endpoints(processableResource=processableResource)
+            for transition in resource.transitions:
+                operationCount = len(renderableApi.operations)
+                method: RenderableMethod = self._transition_to_renderable_method(transition=transition)
+                if transition.isIndirectAction and transition.action.upper() in {'DELETE', 'CREATE', 'UPDATE', 'GET', 'LIST'}:
+                    raise SemanticValidationException(message=f'Only custom transitions can be indirect actions: {transition.action}')
+                if transition.responseType != ResponseTypes.JSON and transition.action.upper() in {'DELETE', 'CREATE', 'UPDATE', 'GET', 'LIST'}:
+                    raise SemanticValidationException(message=f'Only custom transitions can set a responseType: {transition.action}')
+                if transition.action.upper() == 'DELETE':
+                    for endpoint in endpoints.individualEndpoints:
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=None, body=None, responseFields=[], authentication=transition.authentication or api.defaultAuthentication))
+                elif transition.action.upper() == 'CREATE':
+                    parentResource = processableResource.parent.processableResource if processableResource.parent is not None else None
+                    isOneToOne = (processableResource.renderableResource.primaryAttribute == parentResource.renderableResource.primaryAttribute) if parentResource is not None else False
+                    body = [
+                        self._attribute_to_renderable_parameter(attribute=attribute, isRequired=(not attribute.isNullable and attribute.defaultValue is None), knownTypeNames=knownTypeNames)
+                        for attribute in resource.attributes
+                        if attribute.isSettable or (attribute.isPrimary and isOneToOne)
+                    ]
+                    body += [self._request_field_to_renderable_parameter(requestField=requestField, knownTypeNames=knownTypeNames) for requestField in transition.requestFields]
+                    returnValue = RenderableField(name=processableResource.renderableResource.singleName, fieldType=RenderableType(rawType='class', className=processableResource.renderableResource.singleName, isNullable=False, isList=False))
+                    for endpoint in endpoints.collectionEndpoints:
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=None, body=body or None, responseFields=[returnValue], authentication=transition.authentication or api.defaultAuthentication))
+                elif transition.action.upper() == 'UPDATE':
+                    returnValue = RenderableField(name=processableResource.renderableResource.singleName, fieldType=RenderableType(rawType='class', className=processableResource.renderableResource.singleName, isNullable=False, isList=False))
+                    body = [self._attribute_to_renderable_parameter(attribute=attribute, isRequired=False, knownTypeNames=knownTypeNames, shouldUseDefault=False) for attribute in resource.attributes if attribute.isUpdatable]
+                    body += [self._request_field_to_renderable_parameter(requestField=requestField, knownTypeNames=knownTypeNames) for requestField in transition.requestFields]
+                    for endpoint in endpoints.individualEndpoints:
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=None, body=body or None, responseFields=[returnValue], authentication=transition.authentication or api.defaultAuthentication))
+                elif transition.action.upper() == 'GET':
+                    returnValue = RenderableField(name=processableResource.renderableResource.singleName, fieldType=RenderableType(rawType='class', className=processableResource.renderableResource.singleName, isNullable=False, isList=False))
+                    for endpoint in endpoints.individualEndpoints:
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=None, body=None, responseFields=[returnValue], authentication=transition.authentication or api.defaultAuthentication))
+                    endpointsAccessibleWithUnique = [endpoint for endpoint in endpoints.collectionEndpoints if isinstance(endpoint.components[-1], ResourceEndpointComponent)]
+                    uniqueAttributes = [attribute for attribute in resource.attributes if attribute.isUnique and not attribute.isPrimary and not attribute.shouldDisableGetEndpoint and not attribute.isAccessibleIndependently]
+                    for endpoint in endpointsAccessibleWithUnique:
+                        lastComponent = typing.cast(ResourceEndpointComponent, endpoint.components[-1])
+                        for attribute in uniqueAttributes:
+                            getByUniqueEndpoint = RenderableEndpoint(
+                                components=[
+                                    *endpoint.components[:-1],
+                                    ResourceEndpointComponent(
+                                        resource=lastComponent.resource,
+                                        attribute=self._attribute_to_renderable_attribute(attribute=attribute, isNullable=False, knownTypeNames=knownTypeNames),
+                                        relativeSingleName=lastComponent.relativeSingleName,
+                                        relativeCollectionName=lastComponent.relativeCollectionName,
+                                    ),
+                                ]
+                            )
+                            renderableApi.operations.append(RenderableOperation(method=method, endpoint=getByUniqueEndpoint, query=None, body=None, responseFields=[returnValue], authentication=transition.authentication or api.defaultAuthentication))
+                elif transition.action.upper() == 'LIST':
+                    returnValue = RenderableField(name=processableResource.renderableResource.collectionName, fieldType=RenderableType(rawType='class', className=processableResource.renderableResource.singleName, isNullable=False, isList=True))
+                    query = [self._request_field_to_renderable_parameter(requestField=requestField, knownTypeNames=knownTypeNames) for requestField in transition.requestFields]
+                    for endpoint in endpoints.collectionEndpoints:
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=query or None, body=None, responseFields=[returnValue], authentication=transition.authentication or api.defaultAuthentication))
+                else:  # Else it's a custom action
+                    if transition.operatesOn == 'individual':
+                        customEndpoints = endpoints.individualEndpoints
+                    elif transition.operatesOn == 'collection':
+                        customEndpoints = endpoints.collectionEndpoints
+                    else:
+                        raise KibaException(message=f'Resource {processableResource.renderableResource.singleName.pascalCaseString} has custom transition with invalid operatesOn field: {transition.operatesOn}')
+                    for endpoint in customEndpoints:
+                        customEndpoint = RenderableEndpoint(components=[*endpoint.components, ActionEndpointComponent(actionName=RenderableString.from_separated_string(string=transition.action, separator='-'))])
+                        renderableApi.operations.append(self._action_operation(transition=transition, endpoint=customEndpoint, knownTypeNames=knownTypeNames, defaultAuthentication=api.defaultAuthentication, isIndirectAction=transition.isIndirectAction))
+                if len(renderableApi.operations) == operationCount:
+                    uncoveredTransitions.append(f'{renderableResource.singleName.pascalCaseString} {transition.action}')
+        if uncoveredTransitions:
+            raise SemanticValidationException(
+                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)]
+        if operationErrors:
+            raise SemanticValidationException(message='\n'.join(operationErrors))
+        renderableApi.resources.extend(renderableResources)
+        return renderableApi
+
+    def render_directory(self, api: KibaApi, outputDirectoryPath: str) -> None:
+        renderableApi = self.build_renderable_api(api=api)
+        validationErrors = self.languageDefinition.validation_errors(api=renderableApi)
+        if validationErrors:
+            raise SemanticValidationException(message='\n'.join(validationErrors))
+        for path, _, files in os.walk(self.templateDirectoryPath, followlinks=True):
+            outputPathForTemplatePath = path.replace(self.templateDirectoryPath, outputDirectoryPath)
+            targetPath = self._add_service_name_to_path(targetPath=outputPathForTemplatePath, outputDirectoryPath=outputDirectoryPath, serviceName=self.languageDefinition.package_name(api=renderableApi), apiVersion=renderableApi.version.major)
+            templateRelativePath = path.replace(self.templateDirectoryPath, '')
+            logging.debug(msg=f'Creating directory: {targetPath}')
+            os.makedirs(os.path.join(targetPath), exist_ok=True)
+            for filename in files:
+                sourceFilePath = os.path.join(templateRelativePath, filename)
+                if filename.endswith('.j2'):
+                    targetFilename = filename[: -len('.j2')]
+                    targetFilePath = self._add_service_name_to_path(
+                        targetPath=os.path.join(targetPath, targetFilename),
+                        outputDirectoryPath=outputDirectoryPath,
+                        serviceName=self.languageDefinition.package_name(api=renderableApi),
+                        apiVersion=renderableApi.version.major,
+                    )
+                    logging.debug(f'Rendering {sourceFilePath} to: {targetFilePath}')
+                    template = self.jinjaEnvironment.get_template(name=sourceFilePath)
+                    template.globals.update(JINJA_FUNCTIONS)
+                    with open(targetFilePath, 'w') as targetFile:
+                        targetFile.write(template.render(api=renderableApi, target=self.languageDefinition))
+                else:
+                    targetFilePath = self._add_service_name_to_path(
+                        targetPath=os.path.join(targetPath, filename),
+                        outputDirectoryPath=outputDirectoryPath,
+                        serviceName=self.languageDefinition.package_name(api=renderableApi),
+                        apiVersion=renderableApi.version.major,
+                    )
+                    logging.debug(f'Copying {sourceFilePath} to: {targetFilePath}')
+                    with open(os.path.join(self.templateDirectoryPath, sourceFilePath.lstrip('/')), 'r') as sourceFile, open(targetFilePath, 'w') as targetFile:
+                        targetFile.write(sourceFile.read())