geniespec 0.1.1.dev8__tar.gz → 0.1.2.dev4__tar.gz

{geniespec-0.1.1.dev8 → geniespec-0.1.2.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geniespec
-Version: 0.1.1.dev8
+Version: 0.1.2.dev4
 Summary: Generate API code from an api.yaml spec
 License-Expression: MIT
 Requires-Dist: jinja2>=3.1.6
@@ -68,6 +68,29 @@ 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).
 
+## 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
 
 ```
@@ -82,7 +105,9 @@ make install-typescript-client
 make test-typescript-client
 ```
 
-Merges to `main` publish a dev version to PyPI. To release, bump `version` in `pyproject.toml` in a PR, then run the Release workflow on `main` (Actions → Release → Run workflow). It tags `vX.Y.Z` and the Publish workflow publishes it. Only the release workflow can push version tags.
+Merges to `main` publish a dev version to PyPI, except for changes that only touch the landing page. To release, bump `version` in `pyproject.toml` in a PR, then run the Release workflow on `main` (Actions → Release → Run workflow). It tags `vX.Y.Z` and the Publish workflow publishes it. Only the release workflow can push version tags.
+
+`landing/` is the static site for geniespec.com (plain HTML, CSS and JS, no build step). Preview it with `python3 -m http.server --directory landing`. Merges that touch it sync it to the kiba sites bucket and invalidate CloudFront (`.github/workflows/landing-deploy.yml`).
 
 # Things that need work
 

{geniespec-0.1.1.dev8 → geniespec-0.1.2.dev4}/README.md

@@ -54,6 +54,29 @@ 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).
 
+## 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
 
 ```
@@ -68,7 +91,9 @@ make install-typescript-client
 make test-typescript-client
 ```
 
-Merges to `main` publish a dev version to PyPI. To release, bump `version` in `pyproject.toml` in a PR, then run the Release workflow on `main` (Actions → Release → Run workflow). It tags `vX.Y.Z` and the Publish workflow publishes it. Only the release workflow can push version tags.
+Merges to `main` publish a dev version to PyPI, except for changes that only touch the landing page. To release, bump `version` in `pyproject.toml` in a PR, then run the Release workflow on `main` (Actions → Release → Run workflow). It tags `vX.Y.Z` and the Publish workflow publishes it. Only the release workflow can push version tags.
+
+`landing/` is the static site for geniespec.com (plain HTML, CSS and JS, no build step). Preview it with `python3 -m http.server --directory landing`. Merges that touch it sync it to the kiba sites bucket and invalidate CloudFront (`.github/workflows/landing-deploy.yml`).
 
 # Things that need work
 

{geniespec-0.1.1.dev8 → geniespec-0.1.2.dev4}/pyproject.toml

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

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

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

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

@@ -49,7 +49,42 @@ properties:
       - "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
@@ -196,6 +231,11 @@ definitions:
           - "null"
           - string
         pattern: '^[a-z][a-z0-9-]*$'
+      rateLimit:
+        type:
+          - "null"
+          - string
+        pattern: '^[a-z][a-z0-9-]*$'
       responseType:
         type: string
         enum:
@@ -227,6 +267,11 @@ definitions:
           - "null"
           - string
         pattern: '^[a-z][a-z0-9-]*$'
+      rateLimit:
+        type:
+          - "null"
+          - string
+        pattern: '^[a-z][a-z0-9-]*$'
       responseType:
         type: string
         enum:

{geniespec-0.1.1.dev8 → geniespec-0.1.2.dev4}/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.1.dev8 → geniespec-0.1.2.dev4}/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
@@ -370,6 +371,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))
 

{geniespec-0.1.1.dev8 → geniespec-0.1.2.dev4}/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.1.dev8 → geniespec-0.1.2.dev4}/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.1.dev8 → geniespec-0.1.2.dev4}/src/geniespec/types.py

@@ -30,6 +30,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 +118,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 +178,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