geniespec 0.1.2.dev1__tar.gz → 0.1.2.dev5__tar.gz

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geniespec
-Version: 0.1.2.dev1
+Version: 0.1.2.dev5
 Summary: Generate API code from an api.yaml spec
 License-Expression: MIT
 Requires-Dist: jinja2>=3.1.6
@@ -68,6 +68,31 @@ resources:
 
 Fields use it like any other type (`type: ViewContent`, also inside `List` and `Mapping`). `python-server` generates a `ViewContentV1` pydantic discriminated union in `resources`; `typescript-client` generates a `ViewContentV1` union type and a `viewContentV1FromObject` function that builds the member class named by the discriminator (and throws for unknown values).
 
+`type: Uuid` is a string that must be a valid UUID. It works anywhere `String` does, including as a primary attribute in paths. `python-server` types it as `uuid.UUID`, so pydantic rejects other strings with a 400, internal methods get `uuid.UUID` objects and responses write them in the standard lowercase hyphenated form; `typescript-client` types it as `string`.
+
+## Rate limits
+
+Name rate limits at the top level, then pick one per transition with `rateLimit`. `defaultRateLimit` applies to every transition that doesn't set one, and `rateLimit: none` turns it off for a transition, the same way `defaultAuthentication` and `authentication` work:
+
+```yaml
+rateLimits:
+  - name: standard-read
+    perMinute: 30
+    perHour: 300
+  - name: public-read
+    perMinute: 30
+    perHour: 300
+    keyBy: ip
+defaultRateLimit: standard-read
+transitions:
+  - action: GET-HEALTH
+    method: GET
+    authentication: none
+    rateLimit: public-read
+```
+
+A rate limit needs at least one of `perMinute`, `perFiveMinutes`, `perHour` and `perDay`. `keyBy` is `user` (the default) or `ip`. Requests over any window are rejected with a 429. Limits keyed by `user` count per authenticated user, so a transition using one needs `authentication`. `python-server` writes each rate limit as a `RATE_LIMIT_<NAME>` kiba-core `RateLimitConfig` and passes it to `route`; keying by `ip` needs kiba-core's `OriginIpMiddleware`. `typescript-client` ignores rate limits.
+
 # Development
 
 ```

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/README.md

@@ -54,6 +54,31 @@ resources:
 
 Fields use it like any other type (`type: ViewContent`, also inside `List` and `Mapping`). `python-server` generates a `ViewContentV1` pydantic discriminated union in `resources`; `typescript-client` generates a `ViewContentV1` union type and a `viewContentV1FromObject` function that builds the member class named by the discriminator (and throws for unknown values).
 
+`type: Uuid` is a string that must be a valid UUID. It works anywhere `String` does, including as a primary attribute in paths. `python-server` types it as `uuid.UUID`, so pydantic rejects other strings with a 400, internal methods get `uuid.UUID` objects and responses write them in the standard lowercase hyphenated form; `typescript-client` types it as `string`.
+
+## Rate limits
+
+Name rate limits at the top level, then pick one per transition with `rateLimit`. `defaultRateLimit` applies to every transition that doesn't set one, and `rateLimit: none` turns it off for a transition, the same way `defaultAuthentication` and `authentication` work:
+
+```yaml
+rateLimits:
+  - name: standard-read
+    perMinute: 30
+    perHour: 300
+  - name: public-read
+    perMinute: 30
+    perHour: 300
+    keyBy: ip
+defaultRateLimit: standard-read
+transitions:
+  - action: GET-HEALTH
+    method: GET
+    authentication: none
+    rateLimit: public-read
+```
+
+A rate limit needs at least one of `perMinute`, `perFiveMinutes`, `perHour` and `perDay`. `keyBy` is `user` (the default) or `ip`. Requests over any window are rejected with a 429. Limits keyed by `user` count per authenticated user, so a transition using one needs `authentication`. `python-server` writes each rate limit as a `RATE_LIMIT_<NAME>` kiba-core `RateLimitConfig` and passes it to `route`; keying by `ip` needs kiba-core's `OriginIpMiddleware`. `typescript-client` ignores rate limits.
+
 # Development
 
 ```

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/pyproject.toml

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

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/pyproject.toml.orig

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

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/api_schema.yaml

@@ -45,11 +45,46 @@ properties:
     items:
       type: string
   defaultAuthentication:
+    type:
+      - "null"
+      - string
+    pattern: '^[a-z][a-z0-9_-]*$'
+  rateLimits:
+    type: array
+    items:
+      $ref: '#/definitions/RateLimit'
+  defaultRateLimit:
     type:
       - "null"
       - string
     pattern: '^[a-z][a-z0-9-]*$'
 definitions:
+  RateLimit:
+    type: object
+    additionalProperties: false
+    required:
+      - name
+    properties:
+      name:
+        type: string
+        pattern: '^[a-z][a-z0-9-]*$'
+      perMinute:
+        type: integer
+        minimum: 1
+      perFiveMinutes:
+        type: integer
+        minimum: 1
+      perHour:
+        type: integer
+        minimum: 1
+      perDay:
+        type: integer
+        minimum: 1
+      keyBy:
+        type: string
+        enum:
+          - user
+          - ip
   EnumValues:
     type: array
     minItems: 1
@@ -192,6 +227,11 @@ definitions:
       responseField:
         $ref: '#/definitions/ResponseField'
       authentication:
+        type:
+          - "null"
+          - string
+        pattern: '^[a-z][a-z0-9_-]*$'
+      rateLimit:
         type:
           - "null"
           - string
@@ -223,6 +263,11 @@ definitions:
       responseField:
         $ref: '#/definitions/ResponseField'
       authentication:
+        type:
+          - "null"
+          - string
+        pattern: '^[a-z][a-z0-9_-]*$'
+      rateLimit:
         type:
           - "null"
           - string

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/genie.py

@@ -32,6 +32,7 @@ from geniespec.renderable_types import RenderableOneOf
 from geniespec.renderable_types import RenderableOneOfMember
 from geniespec.renderable_types import RenderableOperation
 from geniespec.renderable_types import RenderableParameter
+from geniespec.renderable_types import RenderableRateLimit
 from geniespec.renderable_types import RenderableRawTypes
 from geniespec.renderable_types import RenderableResource
 from geniespec.renderable_types import RenderableString
@@ -46,6 +47,7 @@ from geniespec.types import ComplexTypes
 from geniespec.types import FieldSources
 from geniespec.types import KibaApi
 from geniespec.types import PrimitiveTypes
+from geniespec.types import RateLimitKeys
 from geniespec.types import RequestField
 from geniespec.types import Resource
 from geniespec.types import ResponseField
@@ -114,7 +116,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: dict[str, str], defaultAuthentication: str | None, isIndirectAction: bool = False) -> RenderableOperation:
+    def _action_operation(self, transition: BaseTransition, endpoint: RenderableEndpoint, knownTypeNames: dict[str, str], defaultAuthentication: str | None, defaultRateLimit: 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'
@@ -125,6 +127,7 @@ class Renderer:
             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,
+            rateLimit=transition.rateLimit or defaultRateLimit,
             isIndirectAction=isIndirectAction,
             responseType=transition.responseType,
         )
@@ -344,7 +347,7 @@ class Renderer:
     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]:
+    def _operation_errors(self, operation: RenderableOperation, rateLimitsByName: dict[str, RenderableRateLimit]) -> 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)
@@ -369,6 +372,12 @@ class Renderer:
                 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)
             ]
+        if operation.rateLimit not in (None, 'none'):
+            rateLimit = rateLimitsByName.get(operation.rateLimit)
+            if rateLimit is None:
+                errors.append(f'{name}: unknown rate limit {operation.rateLimit}')
+            elif rateLimit.keyBy == RateLimitKeys.USER and operation.authentication in (None, 'none'):
+                errors.append(f'{name}: rate limit {operation.rateLimit} is keyed by user, so the transition needs authentication')
         return errors
 
     @staticmethod
@@ -414,6 +423,9 @@ class Renderer:
         }
         resourceErrors = [f'Duplicate type name: {name}' for name, count in collections.Counter(fullResourceNames + enumNames + oneOfNames).items() if count > 1]
         resourceErrors += [f'Unknown parent resource {resource.parentResource} for {resource.singleName}' for resource in api.resources if resource.parentResource is not None and resource.parentResource not in fullResourceNames]
+        resourceErrors += [f'Duplicate rate limit: {name}' for name, count in collections.Counter(rateLimit.name for rateLimit in api.rateLimits).items() if count > 1]
+        resourceErrors += ['Rate limit none is reserved for transitions without a rate limit' for rateLimit in api.rateLimits if rateLimit.name == 'none']
+        resourceErrors += [f'Rate limit {rateLimit.name} needs at least one of perMinute, perFiveMinutes, perHour or perDay' for rateLimit in api.rateLimits if all(window is None for window in (rateLimit.perMinute, rateLimit.perFiveMinutes, rateLimit.perHour, rateLimit.perDay))]
         resourcesByName = dict(zip(fullResourceNames, api.resources, strict=False))
         renderableOneOfs: list[RenderableOneOf] = []
         for oneOf in api.oneOfs:
@@ -445,6 +457,7 @@ class Renderer:
                 endpoint=RenderableEndpoint(components=[ActionEndpointComponent(actionName=RenderableString.from_separated_string(string=transition.action, separator='-'))]),
                 knownTypeNames=knownTypeNames,
                 defaultAuthentication=api.defaultAuthentication,
+                defaultRateLimit=api.defaultRateLimit,
             )
             for transition in api.transitions
         ]
@@ -475,6 +488,10 @@ class Renderer:
             exceptions=renderableExceptions,
             enums=[RenderableEnum(name=RenderableString.from_pascal_case_string(string=enum.name), values=enum.values) for enum in api.enums],
             oneOfs=renderableOneOfs,
+            rateLimits=[
+                RenderableRateLimit(name=RenderableString.from_kebab_case_string(string=rateLimit.name), perMinute=rateLimit.perMinute, perFiveMinutes=rateLimit.perFiveMinutes, perHour=rateLimit.perHour, perDay=rateLimit.perDay, keyBy=rateLimit.keyBy)
+                for rateLimit in api.rateLimits
+            ],
         )
         renderableResources: list[RenderableResource] = [self._resource_to_renderable_resource(resource=resource, knownTypeNames=knownTypeNames) for resource in api.resources]
         uncoveredTransitions: list[str] = []
@@ -482,6 +499,8 @@ class Renderer:
             processableResource = self._get_processable_resource(renderableResource=renderableResource, allResources=renderableResources, knownTypeNames=knownTypeNames)
             endpoints = self._get_resource_endpoints(processableResource=processableResource)
             for transition in resource.transitions:
+                authentication = transition.authentication or api.defaultAuthentication
+                rateLimit = transition.rateLimit or api.defaultRateLimit
                 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'}:
@@ -490,7 +509,7 @@ class Renderer:
                     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))
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=None, body=None, responseFields=[], authentication=authentication, rateLimit=rateLimit))
                 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
@@ -502,17 +521,17 @@ class Renderer:
                     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))
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=None, body=body or None, responseFields=[returnValue], authentication=authentication, rateLimit=rateLimit))
                 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))
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=None, body=body or None, responseFields=[returnValue], authentication=authentication, rateLimit=rateLimit))
                 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))
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=None, body=None, responseFields=[returnValue], authentication=authentication, rateLimit=rateLimit))
                     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:
@@ -529,12 +548,12 @@ class Renderer:
                                     ),
                                 ]
                             )
-                            renderableApi.operations.append(RenderableOperation(method=method, endpoint=getByUniqueEndpoint, query=None, body=None, responseFields=[returnValue], authentication=transition.authentication or api.defaultAuthentication))
+                            renderableApi.operations.append(RenderableOperation(method=method, endpoint=getByUniqueEndpoint, query=None, body=None, responseFields=[returnValue], authentication=authentication, rateLimit=rateLimit))
                 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))
+                        renderableApi.operations.append(RenderableOperation(method=method, endpoint=endpoint, query=query or None, body=None, responseFields=[returnValue], authentication=authentication, rateLimit=rateLimit))
                 else:  # Else it's a custom action
                     if transition.operatesOn == 'individual':
                         customEndpoints = endpoints.individualEndpoints
@@ -544,14 +563,15 @@ class Renderer:
                         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))
+                        renderableApi.operations.append(self._action_operation(transition=transition, endpoint=customEndpoint, knownTypeNames=knownTypeNames, defaultAuthentication=api.defaultAuthentication, defaultRateLimit=api.defaultRateLimit, 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)]
+        rateLimitsByName = {rateLimit.name.kebabCaseString: rateLimit for rateLimit in renderableApi.rateLimits}
+        operationErrors = [error for operation in renderableApi.operations for error in self._operation_errors(operation=operation, rateLimitsByName=rateLimitsByName)]
         operationErrors += self._file_errors(resources=renderableResources, exceptions=renderableExceptions)
         if operationErrors:
             raise SemanticValidationException(message='\n'.join(operationErrors))

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/languages.py

@@ -15,6 +15,7 @@ from geniespec.renderable_types import RenderableField
 from geniespec.renderable_types import RenderableOneOf
 from geniespec.renderable_types import RenderableOperation
 from geniespec.renderable_types import RenderableParameter
+from geniespec.renderable_types import RenderableRateLimit
 from geniespec.renderable_types import RenderableRawTypes
 from geniespec.renderable_types import RenderableResource
 from geniespec.renderable_types import RenderableString
@@ -72,6 +73,9 @@ class BaseLanguageDefinition:
     def string_type(self, isNullable: bool) -> str:
         raise NotImplementedError
 
+    def uuid_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
     def enum_type(self, isNullable: bool, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool) -> str:
         raise NotImplementedError
 
@@ -109,6 +113,8 @@ class BaseLanguageDefinition:
             return self.double_type(isNullable=isNullable)
         if yamlType == PrimitiveTypes.STRING:
             return self.string_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.UUID:
+            return self.uuid_type(isNullable=isNullable)
         if yamlType == PrimitiveTypes.BOOLEAN:
             return self.boolean_type(isNullable=isNullable)
         if yamlType == PrimitiveTypes.DATETIME:
@@ -226,9 +232,9 @@ class BaseLanguageDefinition:
                 return output
             if component.attribute.isUnique and not component.attribute.isPrimary:
                 output.append(self.kebab_name(name=component.attribute.name))
-            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))
+            if component.attribute.fieldType.rawType not in (PrimitiveTypes.INTEGER, PrimitiveTypes.LONG_INTEGER, PrimitiveTypes.STRING, PrimitiveTypes.UUID):
+                raise KibaException(message=f'ResourceEndpointComponent created with an invalid attribute type of {component.attribute.fieldType}. Valid types are: integer, long integer, string and uuid.')
+            output.append(self.path_parameter_segment(parameterName=self.identifier(name=component.attribute.name), isInteger=component.attribute.fieldType.rawType in (PrimitiveTypes.INTEGER, PrimitiveTypes.LONG_INTEGER)))
             return output
         raise KibaException(message=f'Unsupported endpoint component: {type(component)}')
 
@@ -342,6 +348,9 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def string_type(self, isNullable: bool) -> str:
         return 'str | None' if isNullable else 'str'
 
+    def uuid_type(self, isNullable: bool) -> str:
+        return 'uuid.UUID | None' if isNullable else 'uuid.UUID'
+
     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)
@@ -370,6 +379,20 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def requires_auth_resolver(cls, api: RenderableApi) -> bool:
         return any(cls.route_auth(operation=operation) is not None for operation in api.operations)
 
+    @staticmethod
+    def route_rate_limit(operation: RenderableOperation) -> str | None:
+        return operation.rateLimit if operation.rateLimit not in (None, 'none') else None
+
+    @staticmethod
+    def rate_limit_constant_name(name: str) -> str:
+        return f'RATE_LIMIT_{RenderableString.from_kebab_case_string(string=name).snakeCaseString.upper()}'
+
+    @staticmethod
+    def rate_limit_config(rateLimit: RenderableRateLimit) -> str:
+        windows = {'perMinute': rateLimit.perMinute, 'perFiveMinutes': rateLimit.perFiveMinutes, 'perHour': rateLimit.perHour, 'perDay': rateLimit.perDay}
+        entries = [f"'{window}': {limit}" for window, limit in windows.items() if limit is not None]
+        return '{' + ', '.join([*entries, f"'keyBy': '{rateLimit.keyBy}'"]) + '}'
+
     def operation_name(self, operation: RenderableOperation) -> str:
         return self.snake_name(name=self._operation_name(operation=operation))
 
@@ -408,6 +431,18 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
             return PythonLanguageDefinition._contains_json(renderableType=renderableType.keyType) or PythonLanguageDefinition._contains_json(renderableType=renderableType.valueType)
         return renderableType.rawType == PrimitiveTypes.JSON
 
+    @staticmethod
+    def _contains_uuid(renderableType: RenderableType) -> bool:
+        if isinstance(renderableType, MappingRenderableType):
+            return PythonLanguageDefinition._contains_uuid(renderableType=renderableType.keyType) or PythonLanguageDefinition._contains_uuid(renderableType=renderableType.valueType)
+        return renderableType.rawType == PrimitiveTypes.UUID
+
+    def requires_uuid(self, api: RenderableApi) -> bool:
+        fieldTypes = [attribute.fieldType for resource in api.resources for attribute in [*resource.attributes, *resource.independentAttributes]]
+        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 []]
+        fieldTypes += [field.fieldType for exception in api.exceptions for field in exception.fields]
+        return any(self._contains_uuid(renderableType=fieldType) for fieldType in fieldTypes)
+
     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)
 
@@ -547,6 +582,9 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
     def string_type(self, isNullable: bool) -> str:
         return self._nullable(typeName='string', isNullable=isNullable)
 
+    def uuid_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)
@@ -665,7 +703,7 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
             return f'{parserName if isLocalReference else f"Resources.{parserName}"}({value} as RawObject)'
         if renderableType.rawType == 'class' and renderableType.className is not None:
             return f'{self.type(renderableType=renderableType, apiVersion=apiVersion, isLocalReference=isLocalReference)}.fromObject({value} as RawObject)'
-        if renderableType.rawType == PrimitiveTypes.STRING:
+        if renderableType.rawType in (PrimitiveTypes.STRING, PrimitiveTypes.UUID):
             return f'String({value})'
         if renderableType.rawType in (PrimitiveTypes.INTEGER, PrimitiveTypes.LONG_INTEGER, PrimitiveTypes.FLOAT, PrimitiveTypes.DOUBLE):
             return f'Number({value})'

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/renderable_types.py

@@ -212,6 +212,7 @@ class RenderableOperation(BaseModel):
     body: list[RenderableParameter] | None
     responseFields: list[RenderableField] | None
     authentication: str | None
+    rateLimit: str | None = None
     isIndirectAction: bool = False
     responseType: str = ResponseTypes.JSON
 
@@ -241,6 +242,15 @@ class RenderableException(BaseModel):
     fields: list[ExceptionRenderableField]
 
 
+class RenderableRateLimit(BaseModel):
+    name: RenderableString
+    perMinute: int | None
+    perFiveMinutes: int | None
+    perHour: int | None
+    perDay: int | None
+    keyBy: str
+
+
 class RenderableApi(BaseModel):
     version: Version
     serviceName: RenderableString
@@ -251,6 +261,7 @@ class RenderableApi(BaseModel):
     exceptions: list[RenderableException]
     enums: list[RenderableEnum] = []
     oneOfs: list[RenderableOneOf] = []
+    rateLimits: list[RenderableRateLimit] = []
 
 
 class ProcessableResource(BaseModel):

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/templates/python-server/{service}/v{version}/api.py.j2

@@ -8,6 +8,9 @@ import datetime
 from core.api.api_request import KibaApiRequest
 from core.api.route import route
 from core.api.route_auth import RouteAuthResolver
+{% if api.rateLimits %}
+from core.api.route_metadata import RateLimitConfig
+{% endif %}
 {% if target.requires_redirect(api=api) %}
 from core.exceptions import FoundRedirectException
 {% endif %}
@@ -16,14 +19,18 @@ from starlette.routing import BaseRoute
 from starlette.routing import Route
 from . import endpoints
 from .internal import {{ target.internal_class_name(api=api) }}
+{% for rateLimit in api.rateLimits %}
+{{ target.rate_limit_constant_name(name=rateLimit.name.kebabCaseString) }}: RateLimitConfig = {{ target.rate_limit_config(rateLimit=rateLimit) }}
+{% endfor %}
 def create_routes(internal: {{ target.internal_class_name(api=api) }}, {% if target.requires_auth_resolver(api=api) %}authResolver: RouteAuthResolver{% else %}authResolver: RouteAuthResolver | None = None{% endif %}) -> list[BaseRoute]:
 
 
 {% for operation in api.operations %}
 {% set auth = target.route_auth(operation=operation) %}
+{% set rate_limit = target.route_rate_limit(operation=operation) %}
 {% set class_name = target.operation_class_name(operation=operation) %}
 {% set result_name = target.identifier(name=operation.responseFields[0].name) if operation.responseFields else 'result' %}
-    @route(requestType=endpoints.{{ class_name }}Request, responseType=endpoints.{{ class_name }}Response{% if target.is_streaming(operation=operation) %}, isStreaming=True{% endif %}{% if auth is not none %}, authResolver=authResolver, auth='{{ auth }}'{% endif %})
+    @route(requestType=endpoints.{{ class_name }}Request, responseType=endpoints.{{ class_name }}Response{% if target.is_streaming(operation=operation) %}, isStreaming=True{% endif %}{% if auth is not none %}, authResolver=authResolver, auth='{{ auth }}'{% endif %}{% if rate_limit is not none %}, rateLimit={{ target.rate_limit_constant_name(name=rate_limit) }}{% endif %})
     async def {{ target.operation_name(operation=operation) }}(request: KibaApiRequest[endpoints.{{ class_name }}Request]) -> {% if target.is_streaming(operation=operation) %}collections.abc.AsyncIterator[endpoints.{{ class_name }}Response]{% else %}endpoints.{{ class_name }}Response{% endif %}:
 {% for parameter in target.request_parameters(operation=operation) %}
 {% set param_name = target.identifier(name=parameter.name) %}

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/templates/python-server/{service}/v{version}/endpoints.py.j2

@@ -4,6 +4,9 @@ import datetime
 {% if target.requires_optional_field_default(api=api) or target.operations_require_typing(api=api) %}
 import typing
 {% endif %}
+{% if target.requires_uuid(api=api) %}
+import uuid
+{% endif %}
 
 {% if target.operations_require_json(api=api) %}
 import pydantic

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/templates/python-server/{service}/v{version}/exceptions.py.j2

@@ -2,6 +2,9 @@
 from __future__ import annotations
 import collections.abc
 import typing
+{% if target.requires_uuid(api=api) %}
+import uuid
+{% endif %}
 {% if target.exceptions_require_json(api=api) %}
 import pydantic
 {% endif %}

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/templates/python-server/{service}/v{version}/internal.py.j2

@@ -5,6 +5,9 @@ import collections.abc
 {% if target.operations_require_typing(api=api) %}
 import typing
 {% endif %}
+{% if target.requires_uuid(api=api) %}
+import uuid
+{% endif %}
 
 {% if target.operations_require_json(api=api) %}
 import pydantic

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/templates/python-server/{service}/v{version}/resources.py.j2

@@ -6,6 +6,9 @@ import datetime
 {% if target.resources_require_typing(api=api) %}
 import typing
 {% endif %}
+{% if target.requires_uuid(api=api) %}
+import uuid
+{% endif %}
 
 {% if target.resources_require_json(api=api) or api.oneOfs %}
 import pydantic

{geniespec-0.1.2.dev1 → geniespec-0.1.2.dev5}/src/geniespec/types.py

@@ -12,11 +12,12 @@ class PrimitiveTypes:
     FLOAT = 'Float'
     DOUBLE = 'Double'
     STRING = 'String'
+    UUID = 'Uuid'
     BOOLEAN = 'Boolean'
     DATETIME = 'Datetime'
     DATE = 'Date'
     JSON = 'Json'
-    ALL: ClassVar[list[str]] = [LONG_INTEGER, INTEGER, FLOAT, DOUBLE, STRING, BOOLEAN, DATETIME, DATE, JSON]
+    ALL: ClassVar[list[str]] = [LONG_INTEGER, INTEGER, FLOAT, DOUBLE, STRING, UUID, BOOLEAN, DATETIME, DATE, JSON]
 
 
 class FieldSources:
@@ -30,6 +31,20 @@ class ResponseTypes:
     REDIRECT = 'redirect'
 
 
+class RateLimitKeys:
+    USER = 'user'
+    IP = 'ip'
+
+
+class ApiRateLimit(BaseModel):
+    name: str
+    perMinute: int | None = None
+    perFiveMinutes: int | None = None
+    perHour: int | None = None
+    perDay: int | None = None
+    keyBy: str = RateLimitKeys.USER
+
+
 class ComplexTypes:
     MAPPING = 'Mapping'
     ALL: ClassVar[list[str]] = [MAPPING]
@@ -104,6 +119,7 @@ class BaseTransition(BaseModel):
     responseField: ResponseField | None = None
     requestFields: list[RequestField] = []
     authentication: str | None = None
+    rateLimit: str | None = None
     responseType: str = ResponseTypes.JSON
 
 
@@ -163,6 +179,8 @@ class KibaApi(BaseModel):
     enums: list[ApiEnum] = []
     oneOfs: list[ApiOneOf] = []
     defaultAuthentication: str | None = None
+    rateLimits: list[ApiRateLimit] = []
+    defaultRateLimit: str | None = None
 
     @property
     def versionObject(self) -> Version:  # noqa: N802