Add basic type wrapping, that support Relay specific logic/fields/interfaces

Author: nodkz

.babelrc

@@ -1,5 +1,4 @@
 {
-  "presets": ["react"],
   "plugins": ["dev-expression", "transform-runtime"],
 
   "env": {
@@ -11,4 +10,4 @@
       "presets": ["es2015-loose-native-modules", "stage-0"]
     }
   }
-}
+}

.eslintignore

@@ -0,0 +1,2 @@
+lib/*
+es/*

src/composeWithRelay.js

@@ -0,0 +1,50 @@
+/* @flow */
+/* eslint-disable no-use-before-define */
+
+import { TypeComposer } from 'graphql-compose';
+import NodeInterface from './nodeInterface';
+import MutationMiddleware from './mutationMiddleware';
+import { toGlobalId } from './globalId';
+import { GraphQLID, GraphQLString } from 'graphql';
+import { getNodeFieldConfig } from './nodeFieldConfig';
+
+// all wrapped typeComposers with Relay, stored in this variable
+// for futher type resolving via NodeInterface.resolveType method
+const typeComposerMap = {};
+
+export function composeWithRelay(
+  typeComposer: TypeComposer
+): TypeComposer {
+  if (typeComposer.getTypeName() === 'RootQuery') {
+    typeComposer.addField('node', getNodeFieldConfig(typeComposerMap));
+    return typeComposer;
+  }
+
+  typeComposerMap[typeComposer.getTypeName()] = typeComposer;
+
+  typeComposer.addFields({
+    id: {
+      type: GraphQLID,
+      description: 'The globally unique ID among all types',
+      resolve: (source) => toGlobalId(
+        typeComposer.getTypeName(),
+        typeComposer.getRecordId(source)
+      ),
+    },
+    _nodeTypeName: {
+      type: GraphQLString,
+      description: 'Cuurent object type name, for resolving via node interface.',
+      resolve: typeComposer.getTypeName(),
+    },
+  });
+
+  typeComposer.addInterface(NodeInterface);
+
+  typeComposer.getResolvers().forEach(resolver => {
+    if (resolver.kind === 'mutation') {
+      resolver.addMiddleware(MutationMiddleware);
+    }
+  });
+
+  return typeComposer;
+}

src/definition.js

@@ -0,0 +1,14 @@
+// RE-EXPORT graphql-compose definitions
+import type {
+  ResolveParams as _ResolveParams,
+} from 'graphql-compose/lib/definition.js';
+
+export type ResolveParams = _ResolveParams;
+
+
+// INTERNAL TYPES
+export type Base64String = string;
+export type ResolvedGlobalId = {
+  type: string,
+  id: string,
+};

src/globalId.js

@@ -0,0 +1,35 @@
+/* @flow */
+
+import {
+  ResolvedGlobalId,
+  Base64String,
+} from './definition.js';
+
+export function base64(i: string): Base64String {
+  return ((new Buffer(i, 'ascii')).toString('base64'));
+}
+
+export function unbase64(i: Base64String): string {
+  return ((new Buffer(i, 'base64')).toString('ascii'));
+}
+
+/**
+ * Takes a type name and an ID specific to that type name, and returns a
+ * "global ID" that is unique among all types.
+ */
+export function toGlobalId(type: string, id: string): string {
+  return base64([type, id].join(':'));
+}
+
+/**
+ * Takes the "global ID" created by toGlobalID, and returns the type name and ID
+ * used to create it.
+ */
+export function fromGlobalId(globalId: string): ResolvedGlobalId {
+  const unbasedGlobalId = unbase64(globalId);
+  const delimiterPos = unbasedGlobalId.indexOf(':');
+  return {
+    type: unbasedGlobalId.substring(0, delimiterPos),
+    id: unbasedGlobalId.substring(delimiterPos + 1),
+  };
+}

src/index.js

@@ -1,31 +1,3 @@
-import { GraphQLSchema } from 'graphql';
-import compose from './compose';
-
-function initGraphqlTypes() {
-  // populate root types in Storage.Types
-  getViewerType();
-  getRootQueryType();
-  getRootMutationType();
-
-  // now all types declared, we are ready to extend types
-  resolveUnresolvedRefs();
-  addAdditionalFields();
-}
-
-function getSchema() {
-  initGraphqlTypes();
-
-  const schemaConfig = { query: getRootQueryType() };
-
-  if (Storage.AdditionalFields.has('RootMutation')) {
-    schemaConfig.mutation = getRootMutationType();
-  }
-
-  return new GraphQLSchema(schemaConfig);
-}
-
-
-export {
-  getSchema,
-};
+import { composeWithRelay } from './composeWithRelay';
 
+export default composeWithRelay;

src/mutationMiddleware.js

@@ -0,0 +1,76 @@
+/* @flow */
+/* eslint-disable no-param-reassign */
+
+import { ResolverMiddleware, TypeComposer } from 'graphql-compose';
+import { GraphQLID, GraphQLString, GraphQLObjectType } from 'graphql';
+import { toGlobalId } from './globalId';
+
+export class MutationMiddleware extends ResolverMiddleware {
+  // constructor(typeComposer, opts = {}) {
+  //   super(typeComposer, opts);
+  // }
+
+  args = (next) => (args) => {
+    const nextArgs = next(args);
+
+    if (!nextArgs.clientMutationId) {
+      nextArgs.clientMutationId = {
+        type: GraphQLString,
+        description: 'The client mutation ID used by clients like Relay to track the mutation. '
+                   + 'If given, returned in the response payload of the mutation.',
+      };
+    }
+
+    return nextArgs;
+  };
+
+
+  resolve = (next) => (resolveParams) => {
+    let clientMutationId;
+
+    if (resolveParams && resolveParams.args && resolveParams.args.input
+        && resolveParams.args.input.clientMutationId) {
+      clientMutationId = resolveParams.args.input.clientMutationId;
+      delete resolveParams.args.input.clientMutationId;
+    }
+
+    return next(resolveParams)
+      .then(res => {
+        res.nodeId = toGlobalId(
+          this.typeComposer.getTypeName(),
+          this.typeComposer.getRecordId(res),
+        );
+        if (clientMutationId) {
+          res.clientMutationId = clientMutationId;
+        }
+        return res;
+      });
+  };
+
+
+  outputType = (next) => (outputType) => {
+    const nextOutputType = next(outputType);
+
+    if (!(nextOutputType instanceof GraphQLObjectType)) {
+      return nextOutputType;
+    }
+
+    const outputTC = new TypeComposer(nextOutputType);
+    if (!outputTC.hasField('nodeId')) {
+      outputTC.addField('nodeId', {
+        type: GraphQLID,
+        description: 'The globally unique ID among all types',
+      });
+    }
+
+    if (!outputTC.hasField('clientMutationId')) {
+      outputTC.addField('clientMutationId', {
+        type: GraphQLString,
+        description: 'The client mutation ID used by clients like Relay to track the mutation. '
+                   + 'If given, returned in the response payload of the mutation.',
+      });
+    }
+
+    return outputTC.getType();
+  };
+}

src/nodeFieldConfig.js

@@ -0,0 +1,46 @@
+/* @flow */
+/* eslint-disable no-param-reassign */
+
+import {
+  GraphQLID,
+  GraphQLNonNull,
+} from 'graphql';
+import { fromGlobalId } from './globalId';
+import NodeInterface from './nodeInterface';
+
+// this fieldConfig must be set to RootQuery.node field
+export function getNodeFieldConfig(typeComposerMap) {
+  return {
+    description: 'Fetches an object that has globally unique ID among all types',
+    type: NodeInterface,
+    args: {
+      id: {
+        type: new GraphQLNonNull(GraphQLID),
+        description: 'The globally unique ID among all types',
+      },
+    },
+    resolve: (source, args, context, info) => {
+      const { type, id } = fromGlobalId(args.id);
+
+      const typeComposer = typeComposerMap[type];
+      if (!typeComposer) {
+        return null;
+      }
+
+      const resolver = typeComposer.getResolver('findById');
+      if (resolver && resolver.resolve) {
+        // suppose that first argument is argument with id field
+        const idArgName = Object.keys(resolver.args)[0];
+
+        return resolver.resolve({
+          source,
+          args: { [idArgName]: id },
+          context,
+          info,
+        });
+      }
+
+      return null;
+    },
+  };
+}

src/nodeInterface.js

@@ -0,0 +1,24 @@
+/* @flow */
+
+import {
+  GraphQLID,
+  GraphQLNonNull,
+  GraphQLInterfaceType,
+} from 'graphql';
+
+const NodeInterface = new GraphQLInterfaceType({
+  name: 'Node',
+  description: 'An object, that can be fetched by the globally unique ID among all types.',
+  fields: () => ({
+    id: {
+      type: new GraphQLNonNull(GraphQLID),
+      description: 'The globally unique ID among all types.',
+    },
+  }),
+  resolveType: (payload) => (
+    // `payload._nodeTypeName` was added to type via composeWithRelay
+    payload._nodeTypeName ? payload._nodeTypeName : null
+  ),
+});
+
+export default NodeInterface;