nautobot 2.4.21__py3-none-any.whl → 3.0.0a3__py3-none-any.whl

nautobot/core/constants.py

@@ -116,6 +116,11 @@ PAGINATE_COUNT_DEFAULT = 50
 # Models excluded from the global search list
 GLOBAL_SEARCH_EXCLUDE_LIST = [
     "anotherexamplemodel",
+    "approvalworkflow",
+    "approvalworkflowdefinition",
+    "approvalworkflowstage",
+    "approvalworkflowstagedefinition",
+    "approvalworkflowstageresponse",
     "cablepath",
     "circuittermination",
     "circuittype",
@@ -135,6 +140,7 @@ GLOBAL_SEARCH_EXCLUDE_LIST = [
     "customlink",
     "devicebay",
     "devicebaytemplate",
+    "deviceclusterassignment",
     "devicetypetosoftwareimagefile",
     "dynamicgroupmembership",
     "exporttemplate",
@@ -204,3 +210,6 @@ GLOBAL_SEARCH_EXCLUDE_LIST = [
     "vrfprefixassignment",
     "webhook",
 ]
+
+# M2M fields that are included by default in API responses if exclude_m2m is not provided
+DEFAULT_M2M_FIELDS = ["tags", "content_types", "object_types"]

nautobot/core/context_processors.py

@@ -1,6 +1,12 @@
+from urllib.parse import urlparse
+
 from django.conf import settings as django_settings
+from django.urls import NoReverseMatch, reverse
 
 from nautobot.core.settings_funcs import sso_auth_enabled
+from nautobot.core.templatetags.helpers import has_one_or_more_perms
+from nautobot.core.utils import lookup
+from nautobot.extras.registry import registry
 
 
 def get_saml_idp():
@@ -40,6 +46,84 @@ def settings(request):
     }
 
 
+def nav_menu(request):
+    """
+    Expose nav menu data for navigation and global search.
+    Also, indicate whether `"nautobot_version_control"` app is installed in order to render branch picker in nav menu.
+    """
+    has_identified_active_link = False
+    related_list_view_link = None
+    if request.resolver_match:
+        # Try to map requested page `view_name` to a specific `model` via `lookup.get_model_for_view_name`.
+        try:
+            model = lookup.get_model_for_view_name(request.resolver_match.view_name)
+        except ValueError:
+            model = None
+
+        # If model mapping above fails, fall back to deriving a `model` from requested page `view_class` `queryset`.
+        if not model:
+            view_func = request.resolver_match.func
+            view_class = None
+            if hasattr(view_func, "view_class"):  # Valid for generic Views
+                view_class = view_func.view_class
+            elif hasattr(view_func, "cls"):  # Valid for UI component framework ViewSets
+                view_class = view_func.cls
+            view_instance = view_class() if view_class else None
+            queryset = getattr(view_instance, "queryset", None)
+            model = getattr(queryset, "model", None)
+
+        # If related `model` reference has been found, map it to a list view link.
+        try:
+            related_list_view_name = lookup.get_route_for_model(model, "list") if model else None
+            related_list_view_link = reverse(related_list_view_name) if related_list_view_name else None
+        except (NoReverseMatch, ValueError):
+            pass
+
+    nav_menu_object = {"tabs": {}}
+
+    if htmx_current_url := request.headers.get("HX-Current-URL"):
+        current_url = urlparse(htmx_current_url).path
+    else:
+        current_url = request.path
+
+    for tab_name, tab_details in registry["nav_menu"]["tabs"].items():
+        if not tab_details["permissions"] or has_one_or_more_perms(request.user, tab_details["permissions"]):
+            nav_menu_object["tabs"][tab_name] = {"groups": {}, "icon": tab_details["icon"]}
+            for group_name, group_details in tab_details["groups"].items():
+                if not group_details["permissions"] or has_one_or_more_perms(
+                    request.user, group_details["permissions"]
+                ):
+                    nav_menu_object["tabs"][tab_name]["groups"][group_name] = {"items": {}}
+                    for item_link, item_details in group_details["items"].items():
+                        if not item_details["permissions"] or has_one_or_more_perms(
+                            request.user, item_details["permissions"]
+                        ):
+                            if has_identified_active_link:
+                                is_active = False
+                            else:
+                                is_active = item_link in [current_url, related_list_view_link]
+                                if is_active:
+                                    has_identified_active_link = True
+
+                            nav_menu_object["tabs"][tab_name]["groups"][group_name]["items"][item_link] = {
+                                "is_active": is_active,
+                                "name": item_details["name"],
+                                "weight": item_details["weight"],
+                            }
+                    if len(nav_menu_object["tabs"][tab_name]["groups"][group_name]["items"]) == 0:
+                        del nav_menu_object["tabs"][tab_name]["groups"][group_name]
+            if len(nav_menu_object["tabs"][tab_name]["groups"]) == 0:
+                del nav_menu_object["tabs"][tab_name]
+
+    nav_menu_version_control = None
+    if "nautobot_version_control" in django_settings.PLUGINS:
+        from nautobot_version_control.utils import active_branch  # pylint: disable=import-error
+
+        nav_menu_version_control = {"active_branch": active_branch()}
+
+    return {"nav_menu": nav_menu_object, "nav_menu_version_control": nav_menu_version_control}
+
+
 def sso_auth(request):
     """
     Expose SSO-related variables for use in generating login URL fragments for external authentication providers.

nautobot/core/filters.py

@@ -5,12 +5,22 @@ import uuid
 from django import forms as django_forms
 from django.conf import settings
 from django.db import models
+from django.db.models.constants import LOOKUP_SEP
+from django.db.models.fields.related import ManyToManyRel, ManyToOneRel, OneToOneRel
 from django.forms.utils import ErrorDict, ErrorList
 from django.utils.encoding import force_str
 from django.utils.text import capfirst
 import django_filters
 from django_filters.constants import EMPTY_VALUES
-from django_filters.utils import get_model_field, label_for_filter, resolve_field, verbose_lookup_expr
+from django_filters.filterset import remote_queryset
+from django_filters.utils import (
+    get_field_parts,
+    get_model_field,
+    label_for_filter,
+    resolve_field,
+    verbose_field_name,
+    verbose_lookup_expr,
+)
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema_field
 import timezone_field
@@ -400,9 +410,75 @@ class MappedPredicatesFilterMixin:
         return qs.distinct()
 
 
+class ModelMultipleChoiceFilter(django_filters.ModelMultipleChoiceFilter):
+    """Subclass of the django-filters class by the same name with an improved default `label` formulation."""
+
+    def __init__(self, *args, **kwargs):
+        if "to_field_name" in kwargs:
+            self.to_field_name = kwargs["to_field_name"]
+        super().__init__(*args, **kwargs)
+
+    @property
+    def to_field_name_label(self):
+        if hasattr(self, "to_field_name") and hasattr(self, "model") and self.to_field_name != "id":
+            field_name = self.field_name
+            if field_name.endswith(f"__{self.to_field_name}"):  # e.g. field_name = "device__name", to_field_name="name"
+                field_name = LOOKUP_SEP.join(field_name.split(LOOKUP_SEP)[:-1])
+            to_field_name = LOOKUP_SEP.join([field_name, self.to_field_name])
+            field_parts = get_field_parts(self.model, to_field_name)  # pylint: disable=no-member
+            if field_parts:
+                return field_parts[-1].verbose_name
+            return self.to_field_name
+        return "ID"
+
+    @property
+    def label(self):  # pylint: disable=arguments-differ,invalid-overridden-method
+        """
+        Override django_filters.Filter.label property to generate a more useful default label.
+
+        Examples:
+            >>> import django_filters
+            >>> from nautobot.core.filters import BaseFilterSet, ModelMultipleChoiceFilter
+            >>> class DemoFilterSet(BaseFilterSet):
+            ...      class Meta:
+            ...          model = Interface
+            ...          fields = []
+            ...      old_device = django_filters.ModelMultipleChoiceFilter(queryset=Device.objects.all(), field_name="device")
+            ...      new_device = ModelMultipleChoiceFilter(queryset=Device.objects.all(), field_name="device")
+            ...      device_name = ModelMultipleChoiceFilter(queryset=Device.objects.all(), field_name="device", to_field_name="name")
+            ...
+            >>> DemoFilterSet().filters["old_device"].label
+            'Device'
+            >>> DemoFilterSet().filters["new_device"].label
+            'Device (ID)'
+            >>> DemoFilterSet().filters["device_name"].label
+            'Device (Name)'
+        """
+        if self._label is None and hasattr(self, "model"):
+            name = verbose_field_name(self.model, self.field_name)  # pylint: disable=no-member
+            if name == "[invalid name]":
+                name = self.field_name
+            verbose_expression = ["exclude", name] if self.exclude else [name]
+
+            # Nautobot-specific enhancement
+            verbose_expression.append(f"({self.to_field_name_label})")
+
+            # iterable lookups indicate a LookupTypeField, which should not be verbose
+            if isinstance(self.lookup_expr, str):
+                verbose_expression.append(verbose_lookup_expr(self.lookup_expr))
+
+            verbose_expression = [force_str(part) for part in verbose_expression if part]
+            self._label = capfirst(" ".join(verbose_expression))
+        return self._label
+
+    @label.setter
+    def label(self, value):  # pylint: disable=invalid-overridden-method
+        self._label = value
+
+
 # TODO(timizuo): NaturalKeyOrPKMultipleChoiceFilter is not currently handling pk Integer field properly; resolve this in issue #3336
 @extend_schema_field(OpenApiTypes.STR)
-class NaturalKeyOrPKMultipleChoiceFilter(django_filters.ModelMultipleChoiceFilter):
+class NaturalKeyOrPKMultipleChoiceFilter(ModelMultipleChoiceFilter):
     """
     Filter that supports filtering on values matching the `pk` field and another
     field of a foreign-key related object. The desired field is set using the `to_field_name`
@@ -425,6 +501,17 @@ class NaturalKeyOrPKMultipleChoiceFilter(django_filters.ModelMultipleChoiceFilte
         self.prefers_id = prefers_id
         super().__init__(*args, **kwargs)
 
+    @property
+    def to_field_name_label(self):
+        """
+        Override ModelMultipleChoiceFilter.to_field_name_label to indicate both field_name options.
+
+        Examples:
+            >>> VirtualMachineFilterSet().filters["software_image_files"].label
+            'Software Image Files (Image File Name or ID)'
+        """
+        return f"{super().to_field_name_label} or ID"
+
     def get_filter_predicate(self, v):
         """
         Override base filter behavior to force the filter to use the `pk` field instead of
@@ -574,9 +661,32 @@ class BaseFilterSet(django_filters.FilterSet):
             models.DecimalField: {"filter_class": MultiValueDecimalFilter},
             models.EmailField: {"filter_class": MultiValueCharFilter},
             models.FloatField: {"filter_class": MultiValueFloatFilter},
+            # TODO: should be NaturalKeyOrPKMultipleChoiceFilter but not all models have a "name" or other natural key
+            models.ForeignKey: {
+                "filter_class": ModelMultipleChoiceFilter,
+                "extra": lambda field: {
+                    "null_label": django_filters.conf.settings.NULL_CHOICE_LABEL if field.null else None,
+                    "queryset": remote_queryset(field),
+                    "to_field_name": field.remote_field.field_name,
+                },
+            },
             models.IntegerField: {"filter_class": MultiValueNumberFilter},
             # Ref: https://github.com/carltongibson/django-filter/issues/1107
             models.JSONField: {"filter_class": MultiValueCharFilter, "extra": lambda f: {"lookup_expr": "icontains"}},
+            models.ManyToManyField: {
+                "filter_class": ModelMultipleChoiceFilter,
+                "extra": lambda f: {
+                    "queryset": remote_queryset(f),
+                },
+            },
+            models.OneToOneField: {
+                "filter_class": ModelMultipleChoiceFilter,
+                "extra": lambda f: {
+                    "queryset": remote_queryset(f),
+                    "to_field_name": f.remote_field.field_name,
+                    "null_label": django_filters.conf.settings.NULL_CHOICE_LABEL if f.null else None,
+                },
+            },
             models.PositiveIntegerField: {"filter_class": MultiValueNumberFilter},
             models.PositiveSmallIntegerField: {"filter_class": MultiValueNumberFilter},
             models.SlugField: {"filter_class": MultiValueCharFilter},
@@ -585,6 +695,25 @@ class BaseFilterSet(django_filters.FilterSet):
             models.TimeField: {"filter_class": MultiValueTimeFilter},
             models.URLField: {"filter_class": MultiValueCharFilter},
             models.UUIDField: {"filter_class": MultiValueUUIDFilter},
+            ManyToManyRel: {
+                "filter_class": ModelMultipleChoiceFilter,
+                "extra": lambda f: {
+                    "queryset": remote_queryset(f),
+                },
+            },
+            ManyToOneRel: {
+                "filter_class": ModelMultipleChoiceFilter,
+                "extra": lambda f: {
+                    "queryset": remote_queryset(f),
+                },
+            },
+            OneToOneRel: {
+                "filter_class": ModelMultipleChoiceFilter,
+                "extra": lambda f: {
+                    "queryset": remote_queryset(f),
+                    "null_label": django_filters.conf.settings.NULL_CHOICE_LABEL if f.null else None,
+                },
+            },
             core_fields.MACAddressCharField: {"filter_class": MultiValueMACAddressFilter},
             core_fields.TagsField: {"filter_class": TagFilter},
             timezone_field.TimeZoneField: {"filter_class": MultiValueCharFilter},

nautobot/core/forms/__init__.py

@@ -35,6 +35,7 @@ from nautobot.core.forms.fields import (
 )
 from nautobot.core.forms.forms import (
     AddressFieldMixin,
+    ApprovalForm,
     BootstrapMixin,
     BulkEditForm,
     BulkRenameForm,
@@ -46,7 +47,7 @@ from nautobot.core.forms.forms import (
     ReturnURLForm,
     TableConfigForm,
 )
-from nautobot.core.forms.search import SearchForm
+from nautobot.core.forms.search import search_model_choices
 from nautobot.core.forms.utils import (
     add_blank_choice,
     add_field_to_filter_form_class,
@@ -87,6 +88,7 @@ __all__ = (
     "APISelect",
     "APISelectMultiple",
     "AddressFieldMixin",
+    "ApprovalForm",
     "AutoPopulateWidget",
     "AutoPositionField",
     "AutoPositionPatternField",
@@ -127,7 +129,6 @@ __all__ = (
     "NumericArrayField",
     "PrefixFieldMixin",
     "ReturnURLForm",
-    "SearchForm",
     "SelectWithDisabled",
     "SelectWithPK",
     "SlugField",
@@ -146,4 +147,5 @@ __all__ = (
     "parse_alphanumeric_range",
     "parse_numeric_range",
     "restrict_form_fields",
+    "search_model_choices",
 )

nautobot/core/forms/fields.py

@@ -482,13 +482,14 @@ class AutoPositionPatternField(ExpandableNameField):
 
 class DynamicModelChoiceMixin:
     """
-    :param display_field: The name of the attribute of an API response object to display in the selection list
-    :param query_params: A dictionary of additional key/value pairs to attach to the API request
-    :param initial_params: A dictionary of child field references to use for selecting a parent field's initial value
-    :param null_option: The string used to represent a null selection (if any)
-    :param disabled_indicator: The name of the field which, if populated, will disable selection of the
-        choice (optional)
-    :param depth: Nested serialization depth when making API requests (default: `0` or a flat representation)
+    Args:
+        display_field (str): The name of the attribute of an API response object to display in the selection list
+        query_params (Optional[dict]): Additional key/value pairs to attach to the API request
+        initial_params (Optional[dict]): Child field references to use for selecting a parent field's initial value
+        null_option (Optional[str]): The string used to represent a null selection (if any)
+        disabled_indicator (Optional[str]): The name of the field which, if populated, will disable selection of the
+            choice
+        depth (int): Nested serialization depth when making API requests (default: `0` or a flat representation)
     """
 
     filter = django_filters.ModelChoiceFilter  # 2.0 TODO(Glenn): can we rename this? pylint: disable=redefined-builtin
@@ -886,7 +887,8 @@ class TagFilterField(DynamicModelMultipleChoiceField):
     """
     A filter field for the tags of a model. Only the tags used by a model are displayed.
 
-    :param model: The model of the filter
+    Args:
+        model (Model): The model of the filter
     """
 
     def __init__(self, model, *args, query_params=None, queryset=None, **kwargs):

nautobot/core/forms/forms.py

@@ -5,12 +5,13 @@ import re
 
 from django import forms
 from django.core.exceptions import FieldDoesNotExist
-from django.db.models.fields.related import ManyToManyField
+from django.db.models.fields.related import ManyToManyField, ManyToManyRel
 from django.forms import formset_factory
 from django.urls import reverse
 import yaml
 
 from nautobot.core.forms import widgets as nautobot_widgets
+from nautobot.core.forms.fields import CommentField
 from nautobot.core.utils.filtering import build_lookup_label, get_filter_field_label, get_filterset_parameter_form_field
 from nautobot.ipam import formfields
 
@@ -87,6 +88,10 @@ class BootstrapMixin(forms.BaseForm):
                 css_classes = field.widget.attrs.get("class", "")
                 if "form-control" not in css_classes:
                     field.widget.attrs["class"] = " ".join([css_classes, "form-control"]).strip()
+            if isinstance(field.widget, (forms.CheckboxInput, forms.RadioSelect)):
+                css_classes = field.widget.attrs.get("class", "")
+                if "form-check" not in css_classes:
+                    field.widget.attrs["class"] = " ".join([css_classes, "form-check-input"]).strip()
             if field.required and not isinstance(field.widget, forms.FileInput):
                 field.widget.attrs["required"] = "required"
             if "placeholder" not in field.widget.attrs:
@@ -109,6 +114,15 @@ class ConfirmationForm(BootstrapMixin, ReturnURLForm):
     confirm = forms.BooleanField(required=True, widget=forms.HiddenInput(), initial=True)
 
 
+class ApprovalForm(BootstrapMixin, ReturnURLForm):
+    """
+    A generic comment form. The form is not valid unless the confirm field is checked.
+    """
+
+    comments = CommentField(label="Comments", required=False)
+    confirm = forms.BooleanField(required=True, widget=forms.HiddenInput(), initial=True)
+
+
 class BulkEditForm(forms.Form):
     """
     Base form for editing multiple objects in bulk.
@@ -146,7 +160,7 @@ class BulkEditForm(forms.Form):
                     continue
                 with contextlib.suppress(FieldDoesNotExist):
                     field = obj._meta.get_field(field_name)
-                    is_m2m_field = isinstance(field, (ManyToManyField, TagsField))
+                    is_m2m_field = isinstance(field, (ManyToManyField, ManyToManyRel, TagsField))
                     if is_m2m_field:
                         m2m_field_names.append(field_name)
 
@@ -273,7 +287,7 @@ class TableConfigForm(BootstrapMixin, forms.Form):
     columns = forms.MultipleChoiceField(
         choices=[],
         required=False,
-        widget=forms.SelectMultiple(attrs={"size": 10}),
+        widget=forms.SelectMultiple(attrs={"size": 20}),
         help_text="Use the buttons below to arrange columns in the desired order, then select all columns to display.",
     )
 
@@ -363,7 +377,7 @@ class DynamicFilterForm(BootstrapMixin, forms.Form):
 
     def _get_lookup_field_choices(self):
         """Get choices for lookup_fields i.e filterset parameters without a lookup expr"""
-        from nautobot.extras.filters.mixins import RelationshipFilter  # Avoid circular import
+        from nautobot.extras.filter_mixins import RelationshipFilter  # Avoid circular import
 
         filterset_without_lookup = (
             (
@@ -381,14 +395,12 @@ def dynamic_formset_factory(filterset, data=None, **kwargs):
     filter_form.filterset = filterset
 
     params = {
-        "can_delete_extra": True,
-        "can_delete": True,
-        "extra": 3,
+        "can_delete_extra": False,
+        "can_delete": False,
+        "extra": 1,
     }
     kwargs.update(params)
     form = formset_factory(form=filter_form, **kwargs)
-    if data:
-        form = form(data=data)
 
     return form
 

nautobot/core/forms/search.py

@@ -1,8 +1,5 @@
-from django import forms
 from django.apps import apps
 
-from nautobot.core.forms import BootstrapMixin
-
 
 def search_model_choices():
     """
@@ -19,15 +16,3 @@ def search_model_choices():
         ]
         choices.append((app_label, model_tuples))
     return choices
-
-
-class SearchForm(BootstrapMixin, forms.Form):
-    q = forms.CharField(label="Search")
-
-    obj_type = forms.ChoiceField(choices=search_model_choices, required=False, label="Type")
-
-    def __init__(self, *args, q_placeholder=None, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        if q_placeholder:
-            self.fields["q"].widget.attrs["placeholder"] = q_placeholder

nautobot/core/forms/widgets.py

@@ -178,8 +178,9 @@ class APISelect(SelectWithDisabled):
         """
         Add details for an additional query param in the form of a data-* JSON-encoded list attribute.
 
-        :param name: The name of the query param
-        :param value: The value of the query param
+        Args:
+            name (str): The name of the query param
+            value (Any): The value of the query param
         """
         key = f"data-query-param-{name}"
 

nautobot/core/graphql/__init__.py

@@ -1,8 +1,7 @@
 from django.test.client import RequestFactory
-from graphene.types import Scalar
+from graphene.types import BigInt
 from graphene_django.settings import graphene_settings
-from graphql import get_default_backend
-from graphql.language import ast
+from graphql import execute, parse
 
 from nautobot.extras.models import GraphQLQuery
 
@@ -24,13 +23,12 @@ def execute_query(query, variables=None, request=None, user=None):
     if not request:
         request = RequestFactory().post("/graphql/")
         request.user = user
-    backend = get_default_backend()
-    schema = graphene_settings.SCHEMA
-    document = backend.document_from_string(schema, query)
+    schema = graphene_settings.SCHEMA.graphql_schema
+    document = parse(query)
     if variables:
-        return document.execute(context_value=request, variable_values=variables)
+        return execute(schema=schema, document=document, context_value=request, variable_values=variables)
     else:
-        return document.execute(context_value=request)
+        return execute(schema=schema, document=document, context_value=request)
 
 
 def execute_saved_query(saved_query_name, **kwargs):
@@ -51,21 +49,5 @@ def execute_saved_query(saved_query_name, **kwargs):
     return execute_query(query=query.query, **kwargs)
 
 
-# See also:
-# https://github.com/graphql-python/graphene-django/issues/241
-# https://github.com/graphql-python/graphene/pull/1261 (graphene 3.0)
-class BigInteger(Scalar):
-    """An integer which, unlike GraphQL's native Int type, doesn't reject values outside (-2^31, 2^31-1).
-
-    Currently only used for ASNField, which goes up to 2^32-1 (i.e., unsigned 32-bit int); it's possible
-    that this approach may fail for values in excess of 2^53-1 (the largest integer value supported in JavaScript).
-    """
-
-    serialize = int
-    parse_value = int
-
-    @staticmethod
-    def parse_literal(node):
-        if isinstance(node, ast.IntValue):
-            return int(node.value)
-        return None
+class BigInteger(BigInt):
+    """For backwards compatibility only."""

nautobot/core/graphql/generators.py

@@ -3,6 +3,7 @@
 import logging
 
 import graphene
+from graphene_django.fields import DjangoListField
 import graphene_django_optimizer as gql_optimizer
 from graphql import GraphQLError
 
@@ -27,7 +28,7 @@ def generate_restricted_queryset():
     fail gracefully in that case.
     """
 
-    def get_queryset(queryset, info):
+    def get_queryset(cls, queryset, info):
         if not hasattr(queryset, "restrict"):
             logger.debug(f"Queryset {queryset} is not restrictable")
             return queryset
@@ -74,9 +75,11 @@ def generate_filter_resolver(schema_type, resolver_name, field_name):
         if not filterset_class or not kwargs:
             return field.all()
 
-        # Inverse of substitution logic from get_filtering_args_from_filterset() - transform "_type" back to "type"
+        # Backwards-compatibility with Nautobot v2 - "_type" as a (now deprecated) alias for "type" filter
         if "_type" in kwargs:
-            kwargs["type"] = kwargs.pop("_type")
+            _type = kwargs.pop("_type")
+            if "type" not in kwargs:
+                kwargs["type"] = _type
 
         resolved_obj = filterset_class(kwargs, field.all())
 
@@ -92,7 +95,7 @@ def generate_filter_resolver(schema_type, resolver_name, field_name):
             errors[key] = resolved_obj.errors[key]
 
         # Raising this exception will send the error message in the response of the GraphQL request
-        raise GraphQLError(errors)
+        raise GraphQLError(str(errors))
 
     resolve_filter.__name__ = resolver_name
     return resolve_filter
@@ -316,6 +319,13 @@ def generate_list_resolver(schema_type, resolver_name):
 
     def list_resolver(self, info, limit=None, offset=None, **kwargs):
         filterset_class = schema_type._meta.filterset_class
+
+        # Backwards-compatibility with Nautobot v2 - "_type" as a (now deprecated) alias for "type" filter
+        if "_type" in kwargs:
+            _type = kwargs.pop("_type")
+            if "type" not in kwargs:
+                kwargs["type"] = _type
+
         if filterset_class is not None:
             resolved_obj = filterset_class(kwargs, model.objects.restrict(info.context.user, "view").all())
 
@@ -329,7 +339,7 @@ def generate_list_resolver(schema_type, resolver_name):
                     errors[key] = resolved_obj.errors[key]
 
                 # Raising this exception will send the error message in the response of the GraphQL request
-                raise GraphQLError(errors)
+                raise GraphQLError(str(errors))
             qs = resolved_obj.qs.all()
 
         else:
@@ -365,7 +375,7 @@ def generate_attrs_for_schema_type(schema_type):
     # Define Attributes for single item and list with their search parameters
     search_params = generate_list_search_parameters(schema_type)
     attrs[single_item_name] = graphene.Field(schema_type, id=graphene.ID())
-    attrs[list_name] = graphene.List(schema_type, **search_params)
+    attrs[list_name] = DjangoListField(schema_type, **search_params)
 
     # Define Resolvers for both single item and list
     single_item_resolver_name = f"{RESOLVER_PREFIX}{single_item_name}"

nautobot/core/graphql/schema.py

@@ -119,7 +119,7 @@ def extend_schema_type(schema_type):
     #
     # Queryset
     #
-    setattr(schema_type, "get_queryset", generate_restricted_queryset())
+    setattr(schema_type, "get_queryset", classmethod(generate_restricted_queryset()))
 
     #
     # Custom Fields

nautobot/core/graphql/schema_init.py

@@ -1,12 +1,11 @@
 import graphene
-from graphene_django.types import ObjectType
 
 from .schema import generate_query_mixin
 
 DynamicGraphQL = generate_query_mixin()
 
 
-class Query(ObjectType, DynamicGraphQL):
+class Query(graphene.ObjectType, DynamicGraphQL):
     """Contains the entire GraphQL Schema definition for Nautobot."""