Refactored basic schema code. Make it faster and cleaner

graphene/contrib/django/fields.py

@@ -1,6 +1,7 @@
 from graphene.core.fields import (
     ListField
 )
+from graphene import relay
 
 from graphene.core.fields import Field, LazyField
 from graphene.utils import cached_property
@@ -21,8 +22,8 @@ class ConnectionOrListField(LazyField):
         schema = self.schema
         model_field = self.field_type
         field_object_type = model_field.get_object_type()
-        if field_object_type and issubclass(field_object_type, schema.relay.Node):
-            field = schema.relay.ConnectionField(model_field)
+        if field_object_type and issubclass(field_object_type, schema.Node):
+            field = relay.ConnectionField(model_field)
         else:
             field = ListField(model_field)
         field.contribute_to_class(self.object_type, self.field_name)

graphene/core/schema.py

@@ -42,6 +42,9 @@ class Schema(object):
             raise Exception('Type %s not found in %r' % (type_name, self))
         return self._types[type_name]
 
+    def __getattr__(self, name):
+        return self.get_type(name)
+
     @property
     def types(self):
         return self._types

graphene/core/types.py

@@ -153,20 +153,3 @@ class Interface(ObjectType):
     class Meta:
         interface = True
         proxy = True
-
-
-@signals.init_schema.connect
-def add_types_to_schema(schema):
-    own_schema = schema
-    class _Interface(Interface):
-        class Meta:
-            schema = own_schema
-            proxy = True
-
-    class _ObjectType(ObjectType):
-        class Meta:
-            schema = own_schema
-            proxy = True
-    
-    setattr(own_schema, 'Interface', _Interface)
-    setattr(own_schema, 'ObjectType', _ObjectType)

graphene/relay/__init__.py

@@ -1,22 +1,10 @@
-from graphene.relay.nodes import (
-	create_node_definitions
-)
-
 from graphene.relay.fields import (
 	ConnectionField,
+	NodeField
 )
 
 import graphene.relay.connections
 
-from graphene.relay.relay import (
-	Relay
+from graphene.relay.nodes import (
+	Node
 )
-
-from graphene.env import get_global_schema
-from graphene.relay.utils import setup
-
-schema = get_global_schema()
-setup(schema)
-relay = schema.relay
-
-Node, NodeField = relay.Node, relay.NodeField

graphene/relay/connections.py

@@ -7,14 +7,12 @@ from graphql_relay.connection.connection import (
 
 from graphene import signals
 from graphene.core.fields import NativeField
-from graphene.relay.utils import get_relay, setup
-from graphene.relay.relay import Relay
 
 
 @signals.class_prepared.connect
 def object_type_created(object_type):
-    relay = get_relay(object_type._meta.schema)
-    if relay and issubclass(object_type, relay.Node):
+    schema = object_type._meta.schema
+    if issubclass(object_type, schema.Node) and object_type != schema.Node:
         if object_type._meta.proxy:
             return
         type_name = object_type._meta.type_name
@@ -24,8 +22,3 @@ def object_type_created(object_type):
 
         connection = connectionDefinitions(type_name, object_type._meta.type).connectionType
         object_type.add_to_class('connection', connection)
-
-
-@signals.init_schema.connect
-def schema_created(schema):
-    setup(schema)

graphene/relay/fields.py

@@ -6,9 +6,8 @@ from graphql_relay.connection.arrayconnection import (
 from graphql_relay.connection.connection import (
     connectionArgs
 )
-from graphene.core.fields import Field
+from graphene.core.fields import Field, LazyNativeField
 from graphene.utils import cached_property
-from graphene.relay.utils import get_relay
 
 
 class ConnectionField(Field):
@@ -25,6 +24,10 @@ class ConnectionField(Field):
     @cached_property
     def type(self):
         object_type = self.get_object_type()
-        relay = get_relay(object_type._meta.schema)
-        assert issubclass(object_type, relay.Node), 'Only nodes have connections.'
+        assert issubclass(object_type, self.schema.Node), 'Only nodes have connections.'
         return object_type.connection
+
+
+class NodeField(LazyNativeField):
+    def get_field(self):
+        return self.schema.Node._definitions.nodeField

graphene/relay/nodes.py

@@ -4,40 +4,34 @@ from graphql_relay.node.node import (
 )
 from graphene.env import get_global_schema
 from graphene.core.types import Interface
-from graphene.core.fields import Field, LazyNativeField
+from graphene.core.fields import LazyNativeField
 
 
-def getSchemaNode(schema=None):
-    def getNode(globalId, *args):
-        _schema = schema or get_global_schema()
-        resolvedGlobalId = fromGlobalId(globalId)
-        _type, _id = resolvedGlobalId.type, resolvedGlobalId.id
-        object_type = schema.get_type(_type) 
-        return object_type.get_node(_id)
-    return getNode
-
-
-def getNodeType(obj):
+def get_node_type(obj):
     return obj._meta.type
 
 
-def create_node_definitions(getNode=None, getNodeType=getNodeType, schema=None):
-    getNode = getNode or getSchemaNode(schema)
-    _nodeDefinitions = nodeDefinitions(getNode, getNodeType)
+def get_node(schema, globalId, *args):
+    resolvedGlobalId = fromGlobalId(globalId)
+    _type, _id = resolvedGlobalId.type, resolvedGlobalId.id
+    object_type = schema.get_type(_type)
+    return object_type.get_node(_id)
 
-    _Interface = getattr(schema, 'Interface', Interface)
+class Node(Interface):
+    _definitions = None
 
-    class Node(_Interface):
-        @classmethod
-        def get_graphql_type(cls):
-            if cls is Node:
-                # Return only nodeInterface when is the Node Inerface
-                return _nodeDefinitions.nodeInterface
-            return super(Node, cls).get_graphql_type()
+    @classmethod
+    def contribute_to_schema(cls, schema):
+        if cls._definitions:
+            return
+        schema = cls._meta.schema
+        cls._definitions = nodeDefinitions(lambda *args: get_node(schema, *args), get_node_type)
 
+    @classmethod
+    def get_graphql_type(cls):
+        if cls is cls._meta.schema.Node:
+            # Return only nodeInterface when is the Node Inerface
+            cls.contribute_to_schema(cls._meta.schema)
+            return cls._definitions.nodeInterface
+        return super(Node, cls).get_graphql_type()
 
-    class NodeField(LazyNativeField):
-        def get_field(self):
-            return _nodeDefinitions.nodeField
-
-    return Node, NodeField

graphene/relay/relay.py

@@ -1,14 +0,0 @@
-from graphene.relay.nodes import (
-	create_node_definitions
-)
-
-from graphene.relay.fields import (
-	ConnectionField,
-)
-
-
-class Relay(object):
-    def __init__(self, schema):
-        self.schema = schema
-        self.Node, self.NodeField = create_node_definitions(schema=self.schema)
-        self.ConnectionField = ConnectionField

graphene/relay/utils.py

@@ -1,9 +0,0 @@
-def get_relay(schema):
-    return getattr(schema, 'relay', None)
-
-
-def setup(schema):
-	from graphene.relay.relay import Relay
-	if not hasattr(schema, 'relay'):
-		return setattr(schema, 'relay', Relay(schema))
-	return schema

tests/relay/test_relay.py

@@ -4,7 +4,6 @@ import graphene
 from graphene import relay
 
 schema = graphene.Schema()
-relay = schema.relay
 
 class OtherNode(relay.Node):
     name = graphene.StringField()

tests/starwars_relay/schema.py

@@ -1,5 +1,5 @@
 import graphene
-from graphene import resolve_only_args
+from graphene import resolve_only_args, relay
 
 from .data import (
     getFaction,
@@ -9,7 +9,6 @@ from .data import (
 )
 
 schema = graphene.Schema(name='Starwars Relay Schema')
-relay = schema.relay
 
 class Ship(relay.Node):
     '''A ship in the Star Wars saga'''
@@ -34,7 +33,7 @@ class Faction(relay.Node):
         return Faction(getFaction(id))
 
 
-class Query(schema.ObjectType):
+class Query(graphene.ObjectType):
     rebels = graphene.Field(Faction)
     empire = graphene.Field(Faction)
     node = relay.NodeField()