Merge pull request #23427 from netbox-community/23423-graphql-64bit-ids

Fixes #23423: Represent 64-bit integer fields as BigInt in GraphQL

netbox/netbox/graphql/filter_mixins.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Annotated, TypeVar
 
 import strawberry
 import strawberry_django
+from strawberry.scalars import ID
 from strawberry_django import BaseFilterLookup, DatetimeFilterLookup, FilterLookup, StrFilterLookup
 
 __all__ = (
@@ -42,11 +43,11 @@ class SyncedDataFilterMixin:
     data_source: Annotated['DataSourceFilter', strawberry.lazy('core.graphql.filters')] | None = (
         strawberry_django.filter_field()
     )
-    data_source_id: FilterLookup[int] | None = strawberry_django.filter_field()
+    data_source_id: ID | None = strawberry_django.filter_field()
     data_file: Annotated['DataFileFilter', strawberry.lazy('core.graphql.filters')] | None = (
         strawberry_django.filter_field()
     )
-    data_file_id: FilterLookup[int] | None = strawberry_django.filter_field()
+    data_file_id: ID | None = strawberry_django.filter_field()
     data_path: StrFilterLookup | None = strawberry_django.filter_field()
     auto_sync_enabled: FilterLookup[bool] | None = strawberry_django.filter_field()
     data_synced: DatetimeFilterLookup | None = strawberry_django.filter_field()

netbox/netbox/graphql/scalars.py

@@ -1,12 +1,34 @@
+import re
 from typing import NewType
 
 import strawberry
+from graphql import GraphQLError
 
 BigInt = NewType('BigInt', int)
 
+BIGINT_MIN = -2**63
+BIGINT_MAX = 2**63 - 1
+
+
+def parse_bigint(value):
+    """
+    Coerce an input value to a signed 64-bit integer. Numeric strings are accepted as well as integers, since many
+    JSON clients cannot represent integers beyond 2^53 as numbers.
+    """
+    if isinstance(value, str) and re.fullmatch(r'-?[0-9]+', value):
+        value = int(value)
+    elif isinstance(value, float) and value.is_integer():
+        value = int(value)
+    if type(value) is not int:
+        raise GraphQLError(f'BigInt cannot represent non-integer value: {value!r}')
+    if not BIGINT_MIN <= value <= BIGINT_MAX:
+        raise GraphQLError(f'BigInt cannot represent non 64-bit signed integer value: {value!r}')
+    return value
+
+
 BigIntScalar = strawberry.scalar(
     name='BigInt',
     serialize=lambda v: int(v),
-    parse_value=lambda v: str(v),
+    parse_value=parse_bigint,
     description='BigInt field',
 )

netbox/netbox/settings.py

@@ -1043,11 +1043,15 @@ for plugin_name in PLUGINS:
 # Monkey-patching
 #
 
+from django.db import models  # noqa: E402
 from rest_framework.utils import field_mapping  # noqa: E402
+from strawberry.schema.types.scalar import DEFAULT_SCALAR_REGISTRY  # noqa: E402
 from strawberry_django import pagination  # noqa: E402
 from strawberry_django.fields.field import StrawberryDjangoField  # noqa: E402
+from strawberry_django.fields.types import field_type_map  # noqa: E402
 
 from netbox.graphql.pagination import OffsetPaginationInput, apply_pagination  # noqa: E402
+from netbox.graphql.scalars import BigInt, BigIntScalar  # noqa: E402
 
 # TODO: Remove this once #20547 has been implemented
 # Override DRF's get_unique_validators() function with our own (see bug #19302)
@@ -1059,6 +1063,16 @@ pagination.OffsetPaginationInput = OffsetPaginationInput
 # Patch StrawberryDjangoField to use our custom `apply_pagination()` method with support for cursor-based pagination
 StrawberryDjangoField.apply_pagination = apply_pagination
 
+# Map 64-bit integer model fields to the BigInt scalar, since GraphQL's Int type is limited to 32 bits
+field_type_map.update({
+    models.BigIntegerField: BigInt,
+    models.PositiveBigIntegerField: BigInt,
+})
+
+# Register the BigInt scalar by default, so that any Strawberry schema (including one built by a plugin) can resolve it
+# without having to declare it in its own scalar_map
+DEFAULT_SCALAR_REGISTRY[BigInt] = BigIntScalar
+
 
 # UNSUPPORTED FUNCTIONALITY: Import any local overrides.
 try:

netbox/netbox/tests/test_graphql.py

@@ -35,8 +35,8 @@ from dcim.models import (
     VirtualChassis,
 )
 from extras.choices import CustomFieldTypeChoices
-from extras.models import CustomField, TableConfig, Tag
-from ipam.models import RIR, Aggregate, IPAddress, Prefix
+from extras.models import CustomField, ExportTemplate, JournalEntry, TableConfig, Tag
+from ipam.models import ASN, RIR, VLAN, Aggregate, IPAddress, Prefix
 from netbox.graphql.pagination import apply_distinct_window_pagination
 from netbox.graphql.scalars import BigInt, BigIntScalar
 from netbox.graphql.schema import Query, get_schema_extensions, schema
@@ -47,6 +47,8 @@ from netbox.tests.dummy_plugin.models import DummySiteAttachment
 from users.models import ObjectPermission, User
 from utilities.tables import get_table_for_model
 from utilities.testing import APITestCase, APIViewTestCases, TestCase, disable_warnings
+from vpn.choices import L2VPNTypeChoices
+from vpn.models import L2VPN, L2VPNTermination
 
 
 def count_primary_table_queries(queries, table):
@@ -455,6 +457,99 @@ class GraphQLAPITestCase(APITestCase):
         self.assertNotIn('errors', data)
         self.assertEqual(len(data['data']['device_list']), 3)
 
+    def test_graphql_64bit_object_ids(self):
+        """
+        Object IDs beyond the 32-bit range must be accepted by GraphQL output fields and filters. Regression test
+        for #23423.
+        """
+        self.add_permissions(
+            'extras.view_journalentry',
+            'extras.view_exporttemplate',
+            'vpn.view_l2vpntermination',
+        )
+        url = reverse('graphql')
+        object_id = 3_000_000_000
+
+        site = Site.objects.create(id=object_id, name='Site 64-bit', slug='site-64-bit')
+        JournalEntry.objects.create(assigned_object=site, comments='Test')
+        vlan = VLAN.objects.create(id=object_id, vid=100, name='VLAN 100')
+        l2vpn = L2VPN.objects.create(name='L2VPN 1', slug='l2vpn-1', type=L2VPNTypeChoices.TYPE_VXLAN)
+        L2VPNTermination.objects.create(l2vpn=l2vpn, assigned_object=vlan)
+        data_source = DataSource.objects.create(id=object_id, name='Data Source 1', type='local', source_url='/tmp')
+        export_template = ExportTemplate.objects.create(
+            name='Export Template 1',
+            template_code='{{ queryset }}',
+            data_source=data_source,
+        )
+        export_template.object_types.set([ObjectType.objects.get_for_model(Site)])
+
+        # Output field (PositiveBigIntegerField)
+        query = '{ journal_entry_list { assigned_object_id } }'
+        response = self.client.post(url, data={'query': query}, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        data = json.loads(response.content)
+        self.assertNotIn('errors', data)
+        self.assertEqual(data['data']['journal_entry_list'], [{'assigned_object_id': object_id}])
+
+        # Filter on a generic object ID
+        query = f'{{ l2vpn_termination_list(filters: {{assigned_object_id: "{object_id}"}}) {{ id }} }}'
+        response = self.client.post(url, data={'query': query}, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        data = json.loads(response.content)
+        self.assertNotIn('errors', data)
+        self.assertEqual(len(data['data']['l2vpn_termination_list']), 1)
+
+        # Filter on a related object ID
+        query = f'{{ export_template_list(filters: {{data_source_id: "{object_id}"}}) {{ id }} }}'
+        response = self.client.post(url, data={'query': query}, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        data = json.loads(response.content)
+        self.assertNotIn('errors', data)
+        self.assertEqual(data['data']['export_template_list'], [{'id': str(export_template.pk)}])
+
+    def test_graphql_bigint_filter_validation(self):
+        """
+        BigInt filter values must be validated as 64-bit integers before the query is executed.
+        """
+        self.add_permissions('ipam.view_asn')
+        url = reverse('graphql')
+        rir = RIR.objects.create(name='RIR 1', slug='rir-1')
+        asn = ASN.objects.create(asn=4_200_000_000, rir=rir)
+
+        # Integers and numeric strings beyond the 32-bit range are accepted
+        for value in ('4200000000', '"4200000000"'):
+            query = f'{{ asn_list(filters: {{asn: {{filter_lookup: {{exact: {value}}}}}}}) {{ id }} }}'
+            response = self.client.post(url, data={'query': query}, format='json', **self.header)
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            data = json.loads(response.content)
+            self.assertNotIn('errors', data)
+            self.assertEqual(data['data']['asn_list'], [{'id': str(asn.pk)}])
+
+        # Non-integer and out-of-range values are rejected
+        for value in ('1.5', '"abc"', 'true', str(2**63)):
+            query = f'{{ asn_list(filters: {{asn: {{filter_lookup: {{exact: {value}}}}}}}) {{ id }} }}'
+            response = self.client.post(url, data={'query': query}, format='json', **self.header)
+            data = json.loads(response.content)
+            self.assertIn('errors', data, msg=f'{value} was not rejected')
+            self.assertIn('BigInt cannot represent', data['errors'][0]['message'])
+
+        # Values passed as variables are validated the same way
+        query = 'query ($asn: BigInt) { asn_list(filters: {asn: {filter_lookup: {exact: $asn}}}) { id } }'
+        for value in (4_200_000_000, '4200000000'):
+            response = self.client.post(
+                url, data={'query': query, 'variables': {'asn': value}}, format='json', **self.header
+            )
+            self.assertHttpStatus(response, status.HTTP_200_OK)
+            data = json.loads(response.content)
+            self.assertNotIn('errors', data)
+            self.assertEqual(data['data']['asn_list'], [{'id': str(asn.pk)}])
+        response = self.client.post(
+            url, data={'query': query, 'variables': {'asn': 'abc'}}, format='json', **self.header
+        )
+        data = json.loads(response.content)
+        self.assertIn('errors', data)
+        self.assertIn('BigInt cannot represent', data['errors'][0]['message'])
+
     def test_graphql_array_length_lookup(self):
         """
         The public GraphQL ``length`` array lookup must map to Django's ``len`` transform.

netbox/vpn/graphql/filters.py

@@ -216,6 +216,4 @@ class L2VPNTerminationFilter(NetBoxModelFilter):
     assigned_object_type: Annotated['ContentTypeFilter', strawberry.lazy('core.graphql.filters')] | None = (
         strawberry_django.filter_field()
     )
-    assigned_object_id: Annotated['IntegerLookup', strawberry.lazy('netbox.graphql.filter_lookups')] | None = (
-        strawberry_django.filter_field()
-    )
+    assigned_object_id: ID | None = strawberry_django.filter_field()