First test, some flow type fixes

Author: nodkz

src/__tests__/globalId-test.js

@@ -0,0 +1,30 @@
+import { expect } from 'chai';
+import {
+  base64,
+  unbase64,
+  toGlobalId,
+  fromGlobalId,
+} from '../globalId';
+
+describe('globalId', () => {
+  it('should have correct method base64()', () => {
+    expect(base64('123')).to.equal('MTIz');
+    expect(base64('lksdnfkksdknsdc:123')).to.equal('bGtzZG5ma2tzZGtuc2RjOjEyMw==');
+  });
+
+  it('should have correct method unbase64()', () => {
+    expect(unbase64('MTIz')).to.equal('123');
+    expect(unbase64('bGtzZG5ma2tzZGtuc2RjOjEyMw==')).to.equal('lksdnfkksdknsdc:123');
+  });
+
+  it('should have correct method toGlobalId()', () => {
+    expect(toGlobalId('User', '789')).to.equal('VXNlcjo3ODk=');
+    expect(toGlobalId('Article', 22)).to.equal('QXJ0aWNsZToyMg==');
+  });
+
+  it('should have correct method fromGlobalId()', () => {
+    expect(fromGlobalId('VXNlcjo3ODk=')).to.deep.equal({ type: 'User', id: '789' });
+    expect(fromGlobalId('QXJ0aWNsZToyMg=='))
+      .to.deep.equal({ type: 'Article', id: '22' });
+  });
+});

src/definition.js

@@ -1,9 +1,33 @@
+/* @flow */
+
 // RE-EXPORT graphql-compose definitions
 import type {
   ResolveParams as _ResolveParams,
+  ResolverMWArgsFn as _ResolverMWArgsFn,
+  ResolverMWArgs as _ResolverMWArgs,
+  ResolverMWResolveFn as _ResolverMWResolveFn,
+  ResolverMWResolve as _ResolverMWResolve,
+  ResolverMWOutputTypeFn as _ResolverMWOutputTypeFn,
+  ResolverMWOutputType as _ResolverMWOutputType,
 } from 'graphql-compose/lib/definition.js';
 
+export type ResolverMWArgsFn = _ResolverMWArgsFn;
+export type ResolverMWArgs = _ResolverMWArgs;
+
+export type ResolverMWResolveFn = _ResolverMWResolveFn;
+export type ResolverMWResolve = _ResolverMWResolve;
+
+export type ResolverMWOutputTypeFn = _ResolverMWOutputTypeFn;
+export type ResolverMWOutputType = _ResolverMWOutputType;
+
+
+import type {
+  TypeComposer as _TypeComposer,
+} from 'graphql-compose';
+
 export type ResolveParams = _ResolveParams;
+export type TypeComposer = _TypeComposer;
+export type TypeComposerMap = {[typeName: string]: TypeComposer};
 
 
 // INTERNAL TYPES

src/globalId.js

@@ -1,6 +1,6 @@
 /* @flow */
 
-import {
+import type {
   ResolvedGlobalId,
   Base64String,
 } from './definition.js';

src/mutationMiddleware.js

@@ -4,13 +4,22 @@
 import { ResolverMiddleware, TypeComposer } from 'graphql-compose';
 import { GraphQLID, GraphQLString, GraphQLObjectType } from 'graphql';
 import { toGlobalId } from './globalId';
+import type {
+  ResolverMWArgsFn,
+  ResolverMWArgs,
+  ResolverMWResolveFn,
+  ResolverMWResolve,
+  ResolverMWOutputTypeFn,
+  ResolverMWOutputType,
+} from './definition';
 
-export class MutationMiddleware extends ResolverMiddleware {
+
+export default class MutationMiddleware extends ResolverMiddleware {
   // constructor(typeComposer, opts = {}) {
   //   super(typeComposer, opts);
   // }
 
-  args = (next) => (args) => {
+  args:ResolverMWArgs = (next: ResolverMWArgsFn) => (args) => {
     const nextArgs = next(args);
 
     if (!nextArgs.clientMutationId) {
@@ -25,7 +34,7 @@ export class MutationMiddleware extends ResolverMiddleware {
   };
 
 
-  resolve = (next) => (resolveParams) => {
+  resolve:ResolverMWResolve = (next: ResolverMWResolveFn) => (resolveParams) => {
     let clientMutationId;
 
     if (resolveParams && resolveParams.args && resolveParams.args.input
@@ -48,7 +57,7 @@ export class MutationMiddleware extends ResolverMiddleware {
   };
 
 
-  outputType = (next) => (outputType) => {
+  outputType:ResolverMWOutputType = (next: ResolverMWOutputTypeFn) => (outputType) => {
     const nextOutputType = next(outputType);
 
     if (!(nextOutputType instanceof GraphQLObjectType)) {

src/nodeFieldConfig.js

@@ -7,9 +7,10 @@ import {
 } from 'graphql';
 import { fromGlobalId } from './globalId';
 import NodeInterface from './nodeInterface';
+import type { TypeComposerMap } from './definition.js';
 
 // this fieldConfig must be set to RootQuery.node field
-export function getNodeFieldConfig(typeComposerMap) {
+export function getNodeFieldConfig(typeComposerMap: TypeComposerMap) {
   return {
     description: 'Fetches an object that has globally unique ID among all types',
     type: NodeInterface,
@@ -19,7 +20,10 @@ export function getNodeFieldConfig(typeComposerMap) {
         description: 'The globally unique ID among all types',
       },
     },
-    resolve: (source, args, context, info) => {
+    resolve: (source: mixed, args: {[argName: string]: mixed}, context: mixed, info: mixed) => {
+      if (!args.id || !(typeof args.id === 'string')) {
+        return null;
+      }
       const { type, id } = fromGlobalId(args.id);
 
       const typeComposer = typeComposerMap[type];