From 95eee095e1160b89cdec2cffcb8392d0d0d8327f Mon Sep 17 00:00:00 2001
From: Nathan <NathHorrigan@gmail.com>
Date: Fri, 27 Mar 2020 18:13:28 +0000
Subject: [PATCH 1/8] Add Query Optimzier that selects fields from query AST

---
 example/db.sqlite3               |   4 +-
 example/example/settings/base.py |   5 +
 example/example/urls.py          |   2 +-
 example/home/models.py           |   2 +
 grapple/apps.py                  |  14 +-
 grapple/db/__init__.py           |   0
 grapple/db/optimizer.py          | 243 +++++++++++++++++++++++++++++++
 grapple/db/query.py              |  88 +++++++++++
 grapple/types/pages.py           |  62 +++++---
 grapple/urls.py                  |   7 +-
 grapple/utils.py                 |   8 +-
 11 files changed, 403 insertions(+), 32 deletions(-)
 create mode 100644 grapple/db/__init__.py
 create mode 100644 grapple/db/optimizer.py
 create mode 100644 grapple/db/query.py

diff --git a/example/db.sqlite3 b/example/db.sqlite3
index 349515a1..21dc7330 100644
--- a/example/db.sqlite3
+++ b/example/db.sqlite3
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6a4d887725df3fca2e2d7703868ba9b90538f49506f9b3ea57515dee785ca90a
-size 872448
+oid sha256:3cf55d959bac4d54de5cb03962245fcde1e0d8e68612be540464948bf26b1dd7
+size 987136
diff --git a/example/example/settings/base.py b/example/example/settings/base.py
index f7a7a2a9..630b98b4 100644
--- a/example/example/settings/base.py
+++ b/example/example/settings/base.py
@@ -54,6 +54,7 @@
     "grapple",
     "graphene_django",
     "channels",
+    "django_extensions",
 ]
 
 MIDDLEWARE = [
@@ -178,3 +179,7 @@
         "ROUTING": "grapple.urls.channel_routing",
     }
 }
+
+# Query Optimisation helpers
+SHELL_PLUS_PRINT_SQL = True
+RUNSERVER_PLUS_PRINT_SQL_TRUNCATE = 100000
diff --git a/example/example/urls.py b/example/example/urls.py
index bad90cf6..05fe60d1 100644
--- a/example/example/urls.py
+++ b/example/example/urls.py
@@ -10,6 +10,7 @@
 from search import views as search_views
 
 urlpatterns = [
+    url(r"", include(grapple_urls)),
     url(r"^django-admin/", admin.site.urls),
     url(r"^admin/", include(wagtailadmin_urls)),
     url(r"^documents/", include(wagtaildocs_urls)),
@@ -18,7 +19,6 @@
     # Wagtail's page serving mechanism. This should be the last pattern in
     # the list:
     url(r"", include(wagtail_urls)),
-    url(r"", include(grapple_urls)),
     # Alternatively, if you want Wagtail pages to be served from a subpath
     # of your site, rather than the site root:
     #    url(r'^pages/', include(wagtail_urls)),
diff --git a/example/home/models.py b/example/home/models.py
index 2fa9e18a..2bc2d30a 100644
--- a/example/home/models.py
+++ b/example/home/models.py
@@ -1,3 +1,4 @@
+from __future__ import unicode_literals
 from django.db import models
 from modelcluster.fields import ParentalKey
 
@@ -6,6 +7,7 @@
 from wagtail.contrib.settings.models import BaseSetting, register_setting
 
 from wagtail.core import blocks
+from wagtail.core.fields import RichTextField, StreamField
 from wagtail.admin.edit_handlers import FieldPanel, StreamFieldPanel, InlinePanel
 from wagtail.images.blocks import ImageChooserBlock
 from wagtail.documents.blocks import DocumentChooserBlock
diff --git a/grapple/apps.py b/grapple/apps.py
index a8ea971d..f05b7ef5 100644
--- a/grapple/apps.py
+++ b/grapple/apps.py
@@ -5,13 +5,21 @@ class Grapple(AppConfig):
     name = "grapple"
 
     def ready(self):
-        """	
-        Import all the django apps defined in django settings then process each model	
-        in these apps and create graphql node types from them.	
+        """
+        Import all the django apps defined in django settings then process each model
+        in these apps and create graphql node types from them.
         """
         from .actions import import_apps, load_type_fields
         from .types.streamfield import register_streamfield_blocks
 
+        self.preload_tasks()
         import_apps()
         load_type_fields()
         register_streamfield_blocks()
+
+    def preload_tasks(self):
+        # Monkeypatch Wagtails' PageQueryset .specific method to a more optimized one
+        from wagtail.core.query import PageQuerySet
+        from .db.query import specific
+
+        PageQuerySet.specific = specific
diff --git a/grapple/db/__init__.py b/grapple/db/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/grapple/db/optimizer.py b/grapple/db/optimizer.py
new file mode 100644
index 00000000..26e4f5b9
--- /dev/null
+++ b/grapple/db/optimizer.py
@@ -0,0 +1,243 @@
+import re
+from collections.abc import Iterable
+from django.db.models.query_utils import DeferredAttribute
+from django.db.models.fields.related_descriptors import (
+    ReverseOneToOneDescriptor,
+    ReverseManyToOneDescriptor,
+    ForwardManyToOneDescriptor,
+    ForwardOneToOneDescriptor,
+    ReverseOneToOneDescriptor,
+)
+from graphene.types.definitions import GrapheneInterfaceType
+from graphql.language.ast import (
+    Field,
+    InlineFragment,
+    FragmentSpread,
+    InterfaceTypeDefinition,
+)
+
+from modelcluster.fields import ParentalKey
+from django.db.models.fields.related import ForeignKey
+
+pascal_to_snake = re.compile(r"(?<!^)(?=[A-Z])")
+
+
+class QueryOptimzer:
+    # Fields extracted from AST that the request wants
+    qs = None
+    schema = None
+    model = None
+    model_type_map = {}
+    query_fields = []
+
+    def __init__(self):
+        # Queryset specific lists (for this query)
+        self.only_fields = []
+        self.select_related_fields = []
+        self.prefetch_related_fields = []
+        # Future Optimisation maps
+        self.only_field_types = {}
+        self.select_related_types = {}
+        self.prefetch_related_types = {}
+
+    @staticmethod
+    def query(qs, info):
+        # Create new optimiser instance.
+        qs_optimizer = QueryOptimzer()
+        qs_optimizer.qs = qs
+        qs_optimizer.schema = info.schema
+        qs_optimizer.model = qs.model
+        # Extract what fields the user wants from the AST.
+        fields, types = AstExplorer(qs, info).parse_ast()
+        qs_optimizer.query_fields = fields
+        qs_optimizer.model_type_map = types
+        # Sort desired fields in how we preload them.
+        qs_optimizer.sort_fields()
+        # Add deferred fields to query.
+        qs_optimizer.optimise_fields()
+        # return the new optimised query
+        return qs_optimizer.qs
+
+    # Sort the requested fields, depending on relation to model.
+    def sort_fields(self):
+        for field_name in self.query_fields:
+            # Make sure field name is snake not pascal (graphene converts them that way)
+            field_name = pascal_to_snake.sub("_", field_name).lower()
+
+            # Support using simple field
+            field = getattr(self.model, field_name, None)
+            if field:
+                self.select_field(field, field_name)
+                continue
+
+            # Support more complex sub-selectable fields
+            field_name_prefix, field_name = field_name.split("__", 1)
+            nested_field = getattr(self.model, field_name_prefix)
+            if nested_field:
+                # Add to query to save recomputing down the line
+                self.select_field(nested_field, field_name, field_name_prefix)
+                continue
+
+    def select_field(self, field, field_name, field_name_prefix=None):
+        model = self.model_type_map.get(field_name_prefix, None)
+        # If link to another model is here then try and parse nested fields
+        if isinstance(field, ReverseOneToOneDescriptor):
+            # Recursion to load nested fields to support specific pages
+            nested_field_name = field_name.split("__")[0]
+            nested_field = getattr(model, nested_field_name, None)
+            if hasattr(nested_field, "field"):
+                return self.select_field(
+                    nested_field.field, nested_field_name, field_name_prefix
+                )
+            else:
+                return self.select_field(
+                    nested_field, nested_field_name, field_name_prefix
+                )
+
+        # Property's or functions can't be selected so we just add id so the query always runs
+        if hasattr(model, "id"):
+            self.only_fields.append("id")
+
+        if not getattr(field, "is_relation", False):
+            if model:
+                # Cache selection for future optimisation (query.py)
+                existing_fields = self.only_field_types.get(field_name_prefix, [])
+                self.only_field_types[field_name_prefix] = [
+                    field_name,
+                    *existing_fields,
+                ]
+            else:
+                self.only_fields.append(field_name)
+
+        elif field.one_to_many or field.many_to_many or isinstance(field, ParentalKey):
+            if model:
+                # Cache selection for future optimisation (query.py)
+                existing_fields = self.prefetch_related_types.get(field_name_prefix, [])
+                self.prefetch_related_types[field_name_prefix] = [
+                    field_name,
+                    *existing_fields,
+                ]
+            else:
+                self.prefetch_related_fields.append(field_name)
+
+        elif field.many_to_one or field.one_to_one:
+            if model:
+                # Cache selection for future optimisation (query.py)
+                existing_fields = self.select_related_types.get(field_name_prefix, [])
+                self.select_related_types[field_name_prefix] = [
+                    field_name,
+                    *existing_fields,
+                ]
+            else:
+                self.only_fields.append(field_name)
+                self.select_related_fields.append(field_name)
+
+    # Apply order fields to querysets
+    def optimise_fields(self):
+        self.qs = self.qs.only(*self.only_fields)
+        self.qs = self.qs.select_related(*self.select_related_fields)
+        self.qs = self.qs.prefetch_related(*self.prefetch_related_fields)
+
+        # Add custom lists to query for use in Specific page optimizer.
+        setattr(self.qs.query, "only_field_types", self.only_field_types)
+        setattr(self.qs.query, "select_related_types", self.select_related_types)
+        setattr(self.qs.query, "prefetch_related_types", self.prefetch_related_types)
+
+
+class AstExplorer:
+    schema = None
+    fragments = {}
+    model_type_map = {}
+    resolve_info = None
+
+    def __init__(self, qs, info):
+        self.schema = info.schema
+        self.resolve_info = info
+        self.fragments = info.fragments
+
+    # Parse AST to find fields
+    def parse_ast(self):
+        pages_interface = self.get_pages_interface()
+        return self.parse_field(pages_interface, None), self.model_type_map
+
+    # Return the pages interface, we only optimise that for now
+    def get_pages_interface(self):
+        for field in self.resolve_info.field_asts:
+            if field.name.value == "page":
+                return field
+            if field.name.value == "pages":
+                return field
+
+    def parse_field(self, field, field_prefix):
+        field_name = field.name.value
+
+        # If field has subset fields
+        if field.selection_set:
+            field_prefix = field_prefix + "__" + field_name if field_prefix else ""
+            return self.parse_selection_set(field.selection_set, field_prefix)
+
+        # Prefix this fieldname with that of it's parent
+        if field_prefix:
+            return field_prefix + "__" + field.name.value
+
+        # Return fields name
+        return field_name
+
+    def parse_selection_set(self, selection_set, field_prefix):
+        selections = []
+        if selection_set.selections:
+            for selection in selection_set.selections:
+                selection = self.parse_selection(selection, field_prefix)
+                if isinstance(selection, list):
+                    selections.extend(selection)
+                else:
+                    selections.append(selection)
+
+        return selections
+
+    def parse_selection(self, selection, field_prefix):
+        if isinstance(selection, InlineFragment):
+            return self.parse_inline_fragment(selection, field_prefix)
+
+        if isinstance(selection, FragmentSpread):
+            return self.parse_fragment_spread(selection, field_prefix)
+
+        if isinstance(selection, Field):
+            return self.parse_field(selection, field_prefix)
+
+    def parse_fragment_spread(self, fragment_spread, field_prefix):
+        # Get fragment name.
+        fragment_name = fragment_spread.name.value
+
+        # Get fragment type from name and return it parsed.
+        fragment_type = self.fragments[fragment_name]
+        return self.parse_inline_fragment(fragment_type, field_prefix)
+
+    def parse_inline_fragment(self, inline_fragment, field_prefix):
+        # Get type of inline fragment
+        gql_type_name = inline_fragment.type_condition.name.value
+        gql_type = self.schema.get_type(gql_type_name)
+
+        # Record what Django model this correlates to
+        type_prefix = gql_type_name.lower()
+        self.model_type_map[type_prefix] = getattr(
+            gql_type.graphene_type._meta, "model", None
+        )
+
+        # Function to add the typename to fieldnames
+        def prefix_type(field):
+            # Don't prefix if the type is an interface
+            if not isinstance(gql_type, GrapheneInterfaceType) and field_prefix:
+                return field_prefix + "__" + field
+
+            return field
+
+        # Get fields of inline fragment
+        selections = []
+        if inline_fragment.selection_set:
+            selections = self.parse_selection_set(
+                inline_fragment.selection_set, type_prefix
+            )
+            selections = list(map(prefix_type, selections))
+
+        return selections
diff --git a/grapple/db/query.py b/grapple/db/query.py
new file mode 100644
index 00000000..dfa62141
--- /dev/null
+++ b/grapple/db/query.py
@@ -0,0 +1,88 @@
+from collections import defaultdict
+
+from wagtail.core.query import DeferredSpecificIterable
+from django.contrib.contenttypes.models import ContentType
+from django.db.models.query import BaseIterable
+
+
+def specific(self, defer=False, *args, **kwargs):
+    """
+    This efficiently gets all the specific pages for the queryset, using
+    the minimum number of queries.
+
+    When the "defer" keyword argument is set to True, only the basic page
+    fields will be loaded and all specific fields will be deferred. It
+    will still generate a query for each page type though (this may be
+    improved to generate only a single query in a future release).
+    """
+    clone = self._clone()
+    if defer:
+        clone._iterable_class = GrappleSpecificIterable
+    else:
+        clone._iterable_class = DeferredSpecificIterable
+
+    return clone
+
+
+class GrappleSpecificIterable(BaseIterable):
+    def __iter__(self):
+        return specific_iterator(self.queryset, defer=True)
+
+
+# Custom version of code from https://github.com/wagtail/wagtail/blob/master/wagtail/core/query.py#L363
+def specific_iterator(qs, defer=True):
+    """
+    This efficiently iterates all the specific pages in a queryset, using
+    the minimum number of queries.
+
+    This should be called from ``PageQuerySet.specific``
+    """
+    pks_and_types = qs.values_list("pk", "content_type")
+    pks_by_type = defaultdict(list)
+    for pk, content_type in pks_and_types:
+        pks_by_type[content_type].append(pk)
+
+    # Content types are cached by ID, so this will not run any queries.
+    content_types = {pk: ContentType.objects.get_for_id(pk) for _, pk in pks_and_types}
+
+    # Get the specific instances of all pages, one model class at a time.
+    pages_by_type = {}
+    for content_type, pks in pks_by_type.items():
+        # look up model class for this content type, falling back on the original
+        # model (i.e. Page) if the more specific one is missing
+        specific_model = content_types[content_type].model_class() or qs.model
+        specific_model_name = specific_model.__name__.lower()
+
+        # Get deffered fields (.only/.deffer)
+        only_fields, _ = qs.query.deferred_loading
+        only_fields_specific = getattr(qs.query, "only_field_types", {}).get(
+            specific_model_name, []
+        )
+        select_related_fields = getattr(qs.query, "select_related_types", {}).get(
+            specific_model_name, []
+        )
+        prefetch_related_fields = getattr(qs.query, "prefetch_related_types", {}).get(
+            specific_model_name, []
+        )
+
+        # If no fields of this model requested then don't query specific
+        if not only_fields:
+            pages_by_type[content_type] = None
+            continue
+
+        # Query pages
+        pages = specific_model.objects.filter(pk__in=pks)
+        # Defer all fields apart from those required
+        pages = pages.only(*only_fields, *only_fields_specific)
+        # Apply select_related fields (passed down from optimizer.py)
+        pages = pages.select_related(*select_related_fields)
+        # Apply prefetch_related fields (passed down from optimizer.py)
+        pages = pages.prefetch_related(*prefetch_related_fields)
+
+        # Replace specific models in same sort order
+        pages_by_type[content_type] = {page.pk: page for page in pages}
+
+    # Yield all of the pages (specific + generic), in the order they occurred in the original query.
+    for pk, content_type in pks_and_types:
+        if pages_by_type[content_type]:
+            yield pages_by_type[content_type][pk]
diff --git a/grapple/types/pages.py b/grapple/types/pages.py
index b138697e..d7719658 100644
--- a/grapple/types/pages.py
+++ b/grapple/types/pages.py
@@ -9,6 +9,7 @@
 
 from ..registry import registry
 from ..utils import resolve_queryset
+from ..db.optimizer import QueryOptimzer
 from .structures import QuerySetList
 
 
@@ -117,30 +118,43 @@ class Meta:
         interfaces = (PageInterface,)
 
 
-def get_specific_page(id, slug, token, content_type=None):
+def get_specific_page(id, slug, url, token, content_type=None, info=None):
     """
     Get a spcecific page, also get preview if token is passed
     """
     page = None
-    try:
-        if id:
-            page = WagtailPage.objects.live().public().specific().get(pk=id)
-        elif slug:
-            page = WagtailPage.objects.live().public().specific().get(slug=slug)
-
-        if token:
-            if page:
-                page_type = type(page)
-                if hasattr(page_type, "get_page_from_preview_token"):
-                    page = page_type.get_page_from_preview_token(token)
-            elif content_type:
-                app_label, model = content_type.lower().split(".")
-                mdl = ContentType.objects.get(app_label=app_label, model=model)
-                cls = mdl.model_class()
-                if hasattr(cls, "get_page_from_preview_token"):
-                    page = cls.get_page_from_preview_token(token)
-    except BaseException:
-        page = None
+    # try:
+    # Generate queryset based on given key & Optimise query based on request AST
+    pages = WagtailPage.objects.live().public()
+    pages = QueryOptimzer.query(pages, info)
+    if id:
+        page = pages.get(id=id)
+    elif slug:
+        page = pages.get(slug=slug)
+    elif url:
+        for matching_page in pages.filter(url_path__contains=url):
+            if matching_page.url == url:
+                page = matching_page
+                break
+
+    if page:
+        page = page.specific
+
+    if token:
+        if page:
+            page_type = type(page)
+            if hasattr(page_type, "get_page_from_preview_token"):
+                page = page_type.get_page_from_preview_token(token)
+
+        elif content_type:
+            app_label, model = content_type.lower().split(".")
+            mdl = ContentType.objects.get(app_label=app_label, model=model)
+            cls = mdl.model_class()
+            if hasattr(cls, "get_page_from_preview_token"):
+                page = cls.get_page_from_preview_token(token)
+
+    # except BaseException:
+    #     page = None
 
     return page
 
@@ -155,6 +169,7 @@ class Mixin:
             PageInterface,
             id=graphene.Int(),
             slug=graphene.String(),
+            url=graphene.String(),
             token=graphene.String(),
             content_type=graphene.String(),
         )
@@ -162,7 +177,7 @@ class Mixin:
         # Return all pages, ideally specific.
         def resolve_pages(self, info, **kwargs):
             return resolve_queryset(
-                WagtailPage.objects.live().public().specific(), info, **kwargs
+                WagtailPage.objects.live().public().specific(defer=True), info, **kwargs
             )
 
         # Return a specific page, identified by ID or Slug.
@@ -170,8 +185,10 @@ def resolve_page(self, info, **kwargs):
             return get_specific_page(
                 id=kwargs.get("id"),
                 slug=kwargs.get("slug"),
+                url=kwargs.get("url"),
                 token=kwargs.get("token"),
                 content_type=kwargs.get("content_type"),
+                info=info,
             )
 
     return Mixin
@@ -190,7 +207,7 @@ def on_updated(sender, token, **kwargs):
 def PagesSubscription():
     def preview_observable(id, slug, token, content_type):
         return preview_subject.filter(lambda previewToken: previewToken == token).map(
-            lambda token: get_specific_page(id, slug, token, content_type)
+            lambda token: get_specific_page(id, slug, token, content_type, info)
         )
 
     class Mixin:
@@ -208,6 +225,7 @@ def resolve_page(self, info, **kwargs):
                 slug=kwargs.get("slug"),
                 token=kwargs.get("token"),
                 content_type=kwargs.get("content_type"),
+                info=info,
             )
 
     return Mixin
diff --git a/grapple/urls.py b/grapple/urls.py
index 0db4855c..aa01935d 100644
--- a/grapple/urls.py
+++ b/grapple/urls.py
@@ -7,6 +7,7 @@
 from channels.routing import route_class
 from graphql_ws.django_channels import GraphQLSubscriptionConsumer
 
+
 def graphiql(request):
     graphiql_settings = {
         "GRAPHIQL_VERSION": "0.11.10",
@@ -19,9 +20,11 @@ def graphiql(request):
 
 
 # Traditional URL routing
-SHOULD_EXPOSE_GRAPHIQL = settings.DEBUG or getattr(settings, 'GRAPPLE_EXPOSE_GRAPHIQL', False)
+SHOULD_EXPOSE_GRAPHIQL = settings.DEBUG or getattr(
+    settings, "GRAPPLE_EXPOSE_GRAPHIQL", False
+)
 urlpatterns = [
-    url(r"^graphql", csrf_exempt(GraphQLView.as_view(graphiql=SHOULD_EXPOSE_GRAPHIQL))),
+    url(r"^graphql", csrf_exempt(GraphQLView.as_view(graphiql=SHOULD_EXPOSE_GRAPHIQL)))
 ]
 
 if SHOULD_EXPOSE_GRAPHIQL:
diff --git a/grapple/utils.py b/grapple/utils.py
index 726d452a..f07070f7 100644
--- a/grapple/utils.py
+++ b/grapple/utils.py
@@ -1,15 +1,18 @@
 import os
 import base64
 import tempfile
+import graphene_django_optimizer as gql_optimizer
 from PIL import Image, ImageFilter
 from django.conf import settings
 from wagtail.search.index import class_is_indexed
 from wagtail.search.models import Query
 from wagtail.search.backends import get_search_backend
 
+from .db.optimizer import QueryOptimzer
+
 
 def resolve_queryset(
-    qs, info, limit=None, offset=None, search_query=None, id=None, order=None, **kwargs
+    qs, info, id=None, limit=None, offset=None, search_query=None, order=None, **kwargs
 ):
     """
     Add limit, offset and search capabilities to the query. This contains
@@ -30,9 +33,10 @@ def resolve_queryset(
     :type order: str
     """
     offset = int(offset or 0)
+    qs = QueryOptimzer.query(qs, info)
 
     if id is not None:
-        qs = qs.filter(pk=id)
+        qs = qs.get(id=id)
     else:
         qs = qs.all()
 

From 4525bd7b045ebf4337ac397af314f5300522819a Mon Sep 17 00:00:00 2001
From: Nathan <NathHorrigan@gmail.com>
Date: Fri, 27 Mar 2020 18:29:22 +0000
Subject: [PATCH 2/8] Add django_extensions to example pip

---
 requirements.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/requirements.txt b/requirements.txt
index b63d86a2..3b8f44ef 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -10,3 +10,4 @@ factory-boy==2.12.0
 wagtail-factories==2.0.0
 django-cors-headers==3.0.2
 wagtail-headless-preview==0.1.4
+django_extensions==2.2.9

From 641bcbaa63680b40b90091a18f01f7b65c80ef31 Mon Sep 17 00:00:00 2001
From: Nathan <NathHorrigan@gmail.com>
Date: Fri, 27 Mar 2020 18:32:39 +0000
Subject: [PATCH 3/8] Remove renduntant changes

---
 example/example/urls.py |  2 +-
 grapple/types/pages.py  | 57 ++++++++++++++++++-----------------------
 grapple/utils.py        |  1 -
 3 files changed, 26 insertions(+), 34 deletions(-)

diff --git a/example/example/urls.py b/example/example/urls.py
index 05fe60d1..bad90cf6 100644
--- a/example/example/urls.py
+++ b/example/example/urls.py
@@ -10,7 +10,6 @@
 from search import views as search_views
 
 urlpatterns = [
-    url(r"", include(grapple_urls)),
     url(r"^django-admin/", admin.site.urls),
     url(r"^admin/", include(wagtailadmin_urls)),
     url(r"^documents/", include(wagtaildocs_urls)),
@@ -19,6 +18,7 @@
     # Wagtail's page serving mechanism. This should be the last pattern in
     # the list:
     url(r"", include(wagtail_urls)),
+    url(r"", include(grapple_urls)),
     # Alternatively, if you want Wagtail pages to be served from a subpath
     # of your site, rather than the site root:
     #    url(r'^pages/', include(wagtail_urls)),
diff --git a/grapple/types/pages.py b/grapple/types/pages.py
index d7719658..7644ca08 100644
--- a/grapple/types/pages.py
+++ b/grapple/types/pages.py
@@ -118,43 +118,38 @@ class Meta:
         interfaces = (PageInterface,)
 
 
-def get_specific_page(id, slug, url, token, content_type=None, info=None):
+def get_specific_page(id, slug, token, content_type=None, info=None):
     """
     Get a spcecific page, also get preview if token is passed
     """
     page = None
-    # try:
-    # Generate queryset based on given key & Optimise query based on request AST
-    pages = WagtailPage.objects.live().public()
-    pages = QueryOptimzer.query(pages, info)
-    if id:
-        page = pages.get(id=id)
-    elif slug:
-        page = pages.get(slug=slug)
-    elif url:
-        for matching_page in pages.filter(url_path__contains=url):
-            if matching_page.url == url:
-                page = matching_page
-                break
-
-    if page:
-        page = page.specific
-
-    if token:
+    try:
+        # Generate queryset based on given key & Optimise query based on request AST
+        pages = WagtailPage.objects.live().public()
+        pages = QueryOptimzer.query(pages, info)
+        if id:
+            page = pages.get(id=id)
+        elif slug:
+            page = pages.get(slug=slug)
+
         if page:
-            page_type = type(page)
-            if hasattr(page_type, "get_page_from_preview_token"):
-                page = page_type.get_page_from_preview_token(token)
+            page = page.specific
+
+        if token:
+            if page:
+                page_type = type(page)
+                if hasattr(page_type, "get_page_from_preview_token"):
+                    page = page_type.get_page_from_preview_token(token)
 
-        elif content_type:
-            app_label, model = content_type.lower().split(".")
-            mdl = ContentType.objects.get(app_label=app_label, model=model)
-            cls = mdl.model_class()
-            if hasattr(cls, "get_page_from_preview_token"):
-                page = cls.get_page_from_preview_token(token)
+            elif content_type:
+                app_label, model = content_type.lower().split(".")
+                mdl = ContentType.objects.get(app_label=app_label, model=model)
+                cls = mdl.model_class()
+                if hasattr(cls, "get_page_from_preview_token"):
+                    page = cls.get_page_from_preview_token(token)
 
-    # except BaseException:
-    #     page = None
+    except BaseException:
+        page = None
 
     return page
 
@@ -169,7 +164,6 @@ class Mixin:
             PageInterface,
             id=graphene.Int(),
             slug=graphene.String(),
-            url=graphene.String(),
             token=graphene.String(),
             content_type=graphene.String(),
         )
@@ -185,7 +179,6 @@ def resolve_page(self, info, **kwargs):
             return get_specific_page(
                 id=kwargs.get("id"),
                 slug=kwargs.get("slug"),
-                url=kwargs.get("url"),
                 token=kwargs.get("token"),
                 content_type=kwargs.get("content_type"),
                 info=info,
diff --git a/grapple/utils.py b/grapple/utils.py
index f07070f7..c4beddb1 100644
--- a/grapple/utils.py
+++ b/grapple/utils.py
@@ -1,7 +1,6 @@
 import os
 import base64
 import tempfile
-import graphene_django_optimizer as gql_optimizer
 from PIL import Image, ImageFilter
 from django.conf import settings
 from wagtail.search.index import class_is_indexed

From e21e9f1de4ae2db15f1db1b7b65c603476954f50 Mon Sep 17 00:00:00 2001
From: Nathan <NathHorrigan@gmail.com>
Date: Wed, 17 Jun 2020 20:32:16 +0100
Subject: [PATCH 4/8] =?UTF-8?q?Fix=20optimizer=20so=20it=20works=20with=20?=
 =?UTF-8?q?dynamic=20graphql=20root=20schema=E2=80=99s?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 grapple/db/optimizer.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/grapple/db/optimizer.py b/grapple/db/optimizer.py
index 26e4f5b9..484a5238 100644
--- a/grapple/db/optimizer.py
+++ b/grapple/db/optimizer.py
@@ -60,7 +60,7 @@ def query(qs, info):
 
     # Sort the requested fields, depending on relation to model.
     def sort_fields(self):
-        for field_name in self.query_fields:
+        for field_name in self.query_fields or []:
             # Make sure field name is snake not pascal (graphene converts them that way)
             field_name = pascal_to_snake.sub("_", field_name).lower()
 
@@ -169,6 +169,10 @@ def get_pages_interface(self):
                 return field
 
     def parse_field(self, field, field_prefix):
+        # Don't crash if the field isn't parsable...
+        if field is None:
+            return
+
         field_name = field.name.value
 
         # If field has subset fields

From d7730f788596196d0156933268eb00c67ff7a2d4 Mon Sep 17 00:00:00 2001
From: Nathan <NathHorrigan@gmail.com>
Date: Thu, 18 Jun 2020 18:22:59 +0100
Subject: [PATCH 5/8] Fix issue with calling property functions

---
 example/db.sqlite3                            |  2 +-
 .../migrations/0015_auto_20200618_1452.py     | 20 +++++++++++++++++++
 example/home/models.py                        |  2 +-
 grapple/db/optimizer.py                       |  4 ++++
 grapple/db/query.py                           |  2 +-
 5 files changed, 27 insertions(+), 3 deletions(-)
 create mode 100644 example/home/migrations/0015_auto_20200618_1452.py

diff --git a/example/db.sqlite3 b/example/db.sqlite3
index 21dc7330..b38c40eb 100644
--- a/example/db.sqlite3
+++ b/example/db.sqlite3
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3cf55d959bac4d54de5cb03962245fcde1e0d8e68612be540464948bf26b1dd7
+oid sha256:238f6c6864e7e0eb078d2fba9d7b61b81aca45a15f8d2910b67c2915b037bb7d
 size 987136
diff --git a/example/home/migrations/0015_auto_20200618_1452.py b/example/home/migrations/0015_auto_20200618_1452.py
new file mode 100644
index 00000000..1d8455dd
--- /dev/null
+++ b/example/home/migrations/0015_auto_20200618_1452.py
@@ -0,0 +1,20 @@
+# Generated by Django 2.2.13 on 2020-06-18 14:52
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('images', '0001_initial'),
+        ('home', '0014_auto_20200303_1234'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='blogpage',
+            name='cover',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='images.CustomImage'),
+        ),
+    ]
diff --git a/example/home/models.py b/example/home/models.py
index 673884f0..e1ddc293 100644
--- a/example/home/models.py
+++ b/example/home/models.py
@@ -58,7 +58,7 @@ class BlogPage(HeadlessPreviewMixin, Page):
         related_name="+",
     )
     cover = models.ForeignKey(
-        "wagtailimages.Image",
+        "images.CustomImage",
         null=True,
         blank=True,
         on_delete=models.SET_NULL,
diff --git a/grapple/db/optimizer.py b/grapple/db/optimizer.py
index 484a5238..f763aa8d 100644
--- a/grapple/db/optimizer.py
+++ b/grapple/db/optimizer.py
@@ -98,6 +98,10 @@ def select_field(self, field, field_name, field_name_prefix=None):
         if hasattr(model, "id"):
             self.only_fields.append("id")
 
+        # Don't select property functions
+        if isinstance(field, property):
+            return
+
         if not getattr(field, "is_relation", False):
             if model:
                 # Cache selection for future optimisation (query.py)
diff --git a/grapple/db/query.py b/grapple/db/query.py
index dfa62141..06a75939 100644
--- a/grapple/db/query.py
+++ b/grapple/db/query.py
@@ -73,7 +73,7 @@ def specific_iterator(qs, defer=True):
         # Query pages
         pages = specific_model.objects.filter(pk__in=pks)
         # Defer all fields apart from those required
-        pages = pages.only(*only_fields, *only_fields_specific)
+        pages = pages.only(*only_fields, *only_fields_specific, *select_related_fields)
         # Apply select_related fields (passed down from optimizer.py)
         pages = pages.select_related(*select_related_fields)
         # Apply prefetch_related fields (passed down from optimizer.py)

From 2bb0d54056e49f0c2bc577c67cad42d1f3977963 Mon Sep 17 00:00:00 2001
From: Nathan <NathHorrigan@gmail.com>
Date: Tue, 7 Jul 2020 21:20:32 +0100
Subject: [PATCH 6/8] Ignore __typename field as it causes null reponse

---
 grapple/db/optimizer.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/grapple/db/optimizer.py b/grapple/db/optimizer.py
index f763aa8d..d90fdca6 100644
--- a/grapple/db/optimizer.py
+++ b/grapple/db/optimizer.py
@@ -64,6 +64,10 @@ def sort_fields(self):
             # Make sure field name is snake not pascal (graphene converts them that way)
             field_name = pascal_to_snake.sub("_", field_name).lower()
 
+            # Ignore typename that causes null error
+            if field_name == "__typename":
+                continue
+
             # Support using simple field
             field = getattr(self.model, field_name, None)
             if field:

From 079148ba904a680ec1a858ff4497db120d46837a Mon Sep 17 00:00:00 2001
From: Nathan <NathHorrigan@gmail.com>
Date: Wed, 8 Jul 2020 16:44:47 +0100
Subject: [PATCH 7/8] Allow processing of fragments

---
 grapple/db/optimizer.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/grapple/db/optimizer.py b/grapple/db/optimizer.py
index d90fdca6..2783433b 100644
--- a/grapple/db/optimizer.py
+++ b/grapple/db/optimizer.py
@@ -223,9 +223,9 @@ def parse_fragment_spread(self, fragment_spread, field_prefix):
 
         # Get fragment type from name and return it parsed.
         fragment_type = self.fragments[fragment_name]
-        return self.parse_inline_fragment(fragment_type, field_prefix)
+        return self.parse_inline_fragment(fragment_type, field_prefix, is_fragment_spread = True)
 
-    def parse_inline_fragment(self, inline_fragment, field_prefix):
+    def parse_inline_fragment(self, inline_fragment, field_prefix, is_fragment_spread = False):
         # Get type of inline fragment
         gql_type_name = inline_fragment.type_condition.name.value
         gql_type = self.schema.get_type(gql_type_name)
@@ -248,7 +248,8 @@ def prefix_type(field):
         selections = []
         if inline_fragment.selection_set:
             selections = self.parse_selection_set(
-                inline_fragment.selection_set, type_prefix
+                inline_fragment.selection_set,
+                field_prefix if is_fragment_spread else type_prefix
             )
             selections = list(map(prefix_type, selections))
 

From b44b3f31ffc96f9670732b4d3e1ad5f659ca7836 Mon Sep 17 00:00:00 2001
From: Rui Saraiva <ruisaraiva19@gmail.com>
Date: Tue, 24 Nov 2020 23:52:43 +0000
Subject: [PATCH 8/8] Fix issue with calling method functions

---
 example/db.sqlite3      | Bin 851968 -> 851968 bytes
 grapple/db/optimizer.py |   4 ++++
 2 files changed, 4 insertions(+)

diff --git a/example/db.sqlite3 b/example/db.sqlite3
index 1090f76b294dfbe0e555183059ba87c72e32ca23..aaa854ffad9a68a289c0e0206817fbac6a749355 100644
GIT binary patch
delta 4765
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
BC_4ZE

delta 1025
zcmZ`%-%C_M6rQ;=cX#f+yPdn)mS(aW`c|}8Gwnf8u!nq746z_^MWlpuO${Hr5aC0}
zsvF&h0vC!FLU2>ud6WGEA~xtjBIt)b1O{s_-UO{?_U_X9(1n>hbLO1$o%5Z~wp(qx
zb)g=wES~AcE3e}(BBUX(nes<F@Y;H4av~6bIO=2*qq9Rpv%~9~=kH?7oS$En6R9f~
z-il*r%U7E^7n|^rz%deGspVMX@h~2~H*<Sva&&5ZY<hYuF>!tUeax~rjbguv{XAsh
zA}sc)OL_X7+9p$A1HlK_5P%P%sYeN;2F!ZH8mkMkAVN$-3?a+1n&nakNAHX{g@{p~
zDlE5(*dhWKiX!$C&;V(`4~nb2xQfGZiFX*`*iwik{PqwWz@7x(hLE3xwW&lxB^axO
z5KYV3dJ$OJJj31lO3>ug)*peBTvmEo#z$j~_#_HzT38eYRfUx*qXc1*2WdJIpD8!4
zr<E<h$k|RRXE&&-nB13Fe#bc7B?pn5N$7$@v*Z-7Pm?c#4*JBx1~;-~KT&3?o0~S9
zhm>vgJ3BE_m!Vy>PZo6(ocJ<bI^Eo#NX#68R=|~Qx-zl@oU5z!6|`S&Yj64I#qlor
z6M1Q2v$Ap)#%2Z!3&&BFh`yuv;D|@Xv-+Pas8qOG_z*-&5yrf}(NNWZMMI`<A2QVR
z{U>b+oa405!<7Rol+Kc+5+yZV{_ldH;96edNe%IuxM%X-3*KcZZ*VC1e+XZ#^ia7}
zKM2ibs4Y^I#gWCj$&G@4R|>KeRk`FOD;`;%-DK~;`B+q%a#1ELkp)UZ%8qeeHJQi0
z82&MveFL?m*f}@JxSQ01`3ghNc%V<eB?miSVYHlNL9eF2Z2YW~s2uw>a0bD6s*bd@
zUAo9!FoIE`>j4B=7!dmJ0dj*hIO!y-btXHF$GQSL2!4r8l+$Irk$52~q`;ipYjC$W
Hpk@C8dFUJS

diff --git a/grapple/db/optimizer.py b/grapple/db/optimizer.py
index dc95ad81..baf2af24 100644
--- a/grapple/db/optimizer.py
+++ b/grapple/db/optimizer.py
@@ -98,6 +98,10 @@ def select_field(self, field, field_name, field_name_prefix=None):
         if isinstance(field, property):
             return
 
+        # Don't select method functions
+        if callable(field):
+            return
+
         if not getattr(field, "is_relation", False):
             if model:
                 # Cache selection for future optimization (query.py)