fix: make Node interface global

Author: nodkz

src/composeWithRelay.js

@@ -11,10 +11,10 @@ import { getNodeFieldConfig } from './nodeFieldConfig';
 // for futher type resolving via NodeInterface.resolveType method
 export const TypeMapForRelayNode = {};
 
-export function composeWithRelay<TSource, TContext>(
-  tc: ObjectTypeComposer<TSource, TContext>
-): ObjectTypeComposer<TSource, TContext> {
-  if (!tc || tc.constructor.name !== 'ObjectTypeComposer') {
+export function composeWithRelay<TContext>(
+  tc: ObjectTypeComposer<any, TContext>
+): ObjectTypeComposer<any, TContext> {
+  if (!(tc instanceof ObjectTypeComposer)) {
     throw new Error('You should provide ObjectTypeComposer instance to composeWithRelay method');
   }
 

src/index.js

@@ -2,7 +2,14 @@
 
 import { composeWithRelay, TypeMapForRelayNode } from './composeWithRelay';
 import { fromGlobalId, toGlobalId } from './globalId';
-import { getNodeInterface } from './nodeInterface';
+import { getNodeInterface, NodeInterface } from './nodeInterface';
 
 export default composeWithRelay;
-export { composeWithRelay, getNodeInterface, TypeMapForRelayNode, fromGlobalId, toGlobalId };
+export {
+  composeWithRelay,
+  getNodeInterface,
+  TypeMapForRelayNode,
+  NodeInterface,
+  fromGlobalId,
+  toGlobalId,
+};

src/nodeInterface.js

@@ -2,30 +2,29 @@
 
 import { InterfaceTypeComposer, type SchemaComposer } from 'graphql-compose';
 
+const NodeTC = InterfaceTypeComposer.createTemp({
+  name: 'Node',
+  description: 'An object, that can be fetched by the globally unique ID among all types.',
+  fields: {
+    id: {
+      type: 'ID!',
+      description: 'The globally unique ID among all types.',
+    },
+  },
+  resolveType: payload => {
+    // `payload.__nodeType` was added to payload via nodeFieldConfig.resolve
+    return payload.__nodeType ? payload.__nodeType : null;
+  },
+});
+
+export const NodeInterface = NodeTC.getType();
+
 export function getNodeInterface<TContex>(
   sc: SchemaComposer<TContex>
 ): InterfaceTypeComposer<any, TContex> {
   if (sc.hasInstance('Node', InterfaceTypeComposer)) {
     return (sc.get('Node'): any);
   }
-
-  const NodeInterface = InterfaceTypeComposer.create(
-    {
-      name: 'Node',
-      description: 'An object, that can be fetched by the globally unique ID among all types.',
-      fields: {
-        id: {
-          type: 'ID!',
-          description: 'The globally unique ID among all types.',
-        },
-      },
-      resolveType: payload => {
-        // `payload.__nodeType` was added to payload via nodeFieldConfig.resolve
-        return payload.__nodeType ? payload.__nodeType : null;
-      },
-    },
-    sc
-  );
-
-  return NodeInterface;
+  sc.set('Node', (NodeTC: any));
+  return (NodeInterface: any);
 }