geniespec 0.1.2.dev7__tar.gz → 0.1.2.dev8__tar.gz

{geniespec-0.1.2.dev7 → geniespec-0.1.2.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geniespec
-Version: 0.1.2.dev7
+Version: 0.1.2.dev8
 Summary: Generate API code from an api.yaml spec
 License-Expression: MIT
 Requires-Dist: jinja2>=3.1.6
@@ -70,6 +70,8 @@ Fields use it like any other type (`type: ViewContent`, also inside `List` and `
 
 `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`.
 
+`type: BigInt` is an integer of any size that travels as a JSON string, because JSON numbers past 2^53 lose precision in JavaScript. `python-server` types it as `int` (a `BigInt` alias in `resources`), accepts `"123"` or `123` in requests, always writes it as a string and documents it as `{"type": "string"}`; `typescript-client` types it as `bigint`, parsed with `BigInt(...)` and sent with `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:

{geniespec-0.1.2.dev7 → geniespec-0.1.2.dev8}/README.md

@@ -56,6 +56,8 @@ Fields use it like any other type (`type: ViewContent`, also inside `List` and `
 
 `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`.
 
+`type: BigInt` is an integer of any size that travels as a JSON string, because JSON numbers past 2^53 lose precision in JavaScript. `python-server` types it as `int` (a `BigInt` alias in `resources`), accepts `"123"` or `123` in requests, always writes it as a string and documents it as `{"type": "string"}`; `typescript-client` types it as `bigint`, parsed with `BigInt(...)` and sent with `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:

{geniespec-0.1.2.dev7 → geniespec-0.1.2.dev8}/pyproject.toml

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

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

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

{geniespec-0.1.2.dev7 → geniespec-0.1.2.dev8}/src/geniespec/languages.py

@@ -78,6 +78,9 @@ class BaseLanguageDefinition:
     def uuid_type(self, isNullable: bool) -> str:
         raise NotImplementedError
 
+    def big_int_type(self, isNullable: bool, isLocalReference: bool) -> str:
+        raise NotImplementedError
+
     def enum_type(self, isNullable: bool, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool) -> str:
         raise NotImplementedError
 
@@ -117,6 +120,8 @@ class BaseLanguageDefinition:
             return self.string_type(isNullable=isNullable)
         if yamlType == PrimitiveTypes.UUID:
             return self.uuid_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.BIG_INT:
+            return self.big_int_type(isNullable=isNullable, isLocalReference=isLocalReference)
         if yamlType == PrimitiveTypes.BOOLEAN:
             return self.boolean_type(isNullable=isNullable)
         if yamlType == PrimitiveTypes.DATETIME:
@@ -353,6 +358,10 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
     def uuid_type(self, isNullable: bool) -> str:
         return 'uuid.UUID | None' if isNullable else 'uuid.UUID'
 
+    def big_int_type(self, isNullable: bool, isLocalReference: bool) -> str:
+        typeName = 'BigInt' if isLocalReference else 'resources.BigInt'
+        return f'{typeName} | None' if isNullable else typeName
+
     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)
@@ -412,10 +421,6 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
         hasResponseDescriptions = any(field.description is not None for operation in api.operations for field in operation.responseFields or [])
         return self.requires_optional_field_default(api=api) or hasRequestDescriptions or hasResponseDescriptions
 
-    @staticmethod
-    def resources_require_field(api: RenderableApi) -> bool:
-        return any(attribute.description is not None for resource in api.resources for attribute in resource.attributes)
-
     @staticmethod
     def _field_default(default: str | None, description: str | None, fieldFunction: str = 'Field', shouldUseField: bool = False) -> str:
         if description is None and not shouldUseField:
@@ -487,13 +492,21 @@ class PythonLanguageDefinition(BaseLanguageDefinition):
             'collections': lambda part: part.isList or isinstance(part, MappingRenderableType),
             'datetime': lambda part: part.rawType in (PrimitiveTypes.DATETIME, PrimitiveTypes.DATE),
             'json': lambda part: part.rawType == PrimitiveTypes.JSON,
-            'resources': lambda part: part.className is not None,
+            'resources': lambda part: part.className is not None or part.rawType == PrimitiveTypes.BIG_INT,
             'uuid': lambda part: part.rawType == PrimitiveTypes.UUID,
         }
         return any(predicates[requirement](part) for fieldType in self._module_field_types(api=api, module=module) for part in self._type_parts(renderableType=fieldType))
 
+    def requires_big_int(self, api: RenderableApi) -> bool:
+        return any(part.rawType == PrimitiveTypes.BIG_INT for module in ('resources', 'internal', 'exceptions') for fieldType in self._module_field_types(api=api, module=module) for part in self._type_parts(renderableType=fieldType))
+
     def resources_require_typing(self, api: RenderableApi) -> bool:
-        return len(api.enums) > 0 or len(api.oneOfs) > 0 or any(self.is_inline_enum(renderableType=attribute.fieldType) for resource in api.resources for attribute in resource.attributes)
+        hasInlineEnums = any(self.is_inline_enum(renderableType=attribute.fieldType) for resource in api.resources for attribute in resource.attributes)
+        return len(api.enums) > 0 or len(api.oneOfs) > 0 or hasInlineEnums or self.requires_big_int(api=api)
+
+    def resources_require_pydantic(self, api: RenderableApi) -> bool:
+        hasDescriptions = any(attribute.description is not None for resource in api.resources for attribute in resource.attributes)
+        return len(api.oneOfs) > 0 or hasDescriptions or self.module_requires(api=api, module='resources', requirement='json') or self.requires_big_int(api=api)
 
     def one_of_alias(self, oneOf: RenderableOneOf, apiVersion: Version) -> str:
         return f'typing.Annotated[{" | ".join(self.one_of_member_class_names(oneOf=oneOf, apiVersion=apiVersion))}, pydantic.Field(discriminator={self.identifier(name=oneOf.discriminator)!r})]'
@@ -602,6 +615,9 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
     def long_integer_type(self, isNullable: bool) -> str:
         return self._nullable(typeName='number', isNullable=isNullable)
 
+    def big_int_type(self, isNullable: bool, isLocalReference: bool) -> str:  # noqa: ARG002
+        return self._nullable(typeName='bigint', isNullable=isNullable)
+
     def mapping_type(self, isNullable: bool, keyType: str, valueType: str) -> str:  # noqa: ARG002
         # NOTE(krishan711): json object keys are always strings
         return self._nullable(typeName=f'Record<string, {valueType}>', isNullable=isNullable)
@@ -752,6 +768,8 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
             return f'String({value})'
         if renderableType.rawType in (PrimitiveTypes.INTEGER, PrimitiveTypes.LONG_INTEGER, PrimitiveTypes.FLOAT, PrimitiveTypes.DOUBLE):
             return f'Number({value})'
+        if renderableType.rawType == PrimitiveTypes.BIG_INT:
+            return f'BigInt(String({value}))'
         if renderableType.rawType == PrimitiveTypes.BOOLEAN:
             return f'Boolean({value})'
         if renderableType.rawType in (PrimitiveTypes.DATE, PrimitiveTypes.DATETIME):
@@ -765,7 +783,7 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
     def _is_serialized_as_is(self, renderableType: RenderableType) -> bool:
         if isinstance(renderableType, MappingRenderableType):
             return self._is_serialized_as_is(renderableType=renderableType.valueType)
-        return renderableType.rawType not in ('class', RenderableRawTypes.ONE_OF, PrimitiveTypes.DATE, PrimitiveTypes.DATETIME)
+        return renderableType.rawType not in ('class', RenderableRawTypes.ONE_OF, PrimitiveTypes.DATE, PrimitiveTypes.DATETIME, PrimitiveTypes.BIG_INT)
 
     def to_object(self, renderableType: RenderableType, value: str, apiVersion: Version, isOptional: bool = False, isLocalReference: bool = False) -> str:
         if self._is_serialized_as_is(renderableType=renderableType):
@@ -787,4 +805,6 @@ class TypeScriptLanguageDefinition(BaseLanguageDefinition):
             return f'dateToString({value})'
         if renderableType.rawType == PrimitiveTypes.DATE:
             return f"dateToString({value}, 'yyyy-MM-dd')"
+        if renderableType.rawType == PrimitiveTypes.BIG_INT:
+            return f'String({value})'
         raise KibaException(f'Failed to render conversion to object for: {renderableType}')

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

@@ -14,13 +14,17 @@ import typing
 import uuid
 {% endif %}
 
-{% if target.module_requires(api=api, module='resources', requirement='json') or api.oneOfs or target.resources_require_field(api=api) %}
+{% if target.resources_require_pydantic(api=api) %}
 import pydantic
 {% endif %}
 {% if api.resources %}
 from pydantic import BaseModel
 {% endif %}
 
+{% if target.requires_big_int(api=api) %}
+BigInt = typing.Annotated[int, pydantic.PlainSerializer(str, return_type=str), pydantic.WithJsonSchema({'type': 'string'})]
+
+{% endif %}
 {% for enum in api.enums %}
 {{ target.enum_class_name(enum=enum, apiVersion=api.version) }} = {{ target.enum_literal(values=enum.values) }}
 {% if loop.last %}

{geniespec-0.1.2.dev7 → geniespec-0.1.2.dev8}/src/geniespec/types.py

@@ -13,11 +13,12 @@ class PrimitiveTypes:
     DOUBLE = 'Double'
     STRING = 'String'
     UUID = 'Uuid'
+    BIG_INT = 'BigInt'
     BOOLEAN = 'Boolean'
     DATETIME = 'Datetime'
     DATE = 'Date'
     JSON = 'Json'
-    ALL: ClassVar[list[str]] = [LONG_INTEGER, INTEGER, FLOAT, DOUBLE, STRING, UUID, BOOLEAN, DATETIME, DATE, JSON]
+    ALL: ClassVar[list[str]] = [LONG_INTEGER, INTEGER, FLOAT, DOUBLE, STRING, UUID, BIG_INT, BOOLEAN, DATETIME, DATE, JSON]
 
 
 class FieldSources: